> No problems there, agreed 👍 Regarding todo list vs templates @comintern. Would @retailcoder append/update his feature request with Github team if proven useful to RD as he mentioned tags with projects.
> Just to clarify (and document a bit further), ByVal is supported here to explicitly pass the argument by value, but ByRef results in a compile error.
> People who you don’t know will be able to watch you. Everything that happens in the video call can be recorded and made publicly available for later playback. The moderator of the Hangout On Air is able to control your audio/video settings during the call (such as turning your camera on or off), and also has the ability to eject you from the call.
> @bclothier - There's a 2nd commit that followed that one that removed it again - I didn't find it until I was writing the unit tests. It's a bit ahem underspecified in the MS documentation.
I use the following code to import multiple worksheets from another workbook and do some processing. the Importing time is too long. can any one suggest a more efficient way to import? Should I be looking in to more information in the source files for copy?
I am not a professional developer, so ...
It's a pleasure to meet the face @Mat'sMug. There's a slight lag in the sound I note which resolves when I lowered the resolution from HD on youtube. Tricky at times to follow with my excellent lip-reading skills, will take me a while to get through two hours. Good and entertaining show. Thanks.
I'm thinking that's just some weirdness around what Excel is doing when it goes down. The recovery restart is entirely in the Excel domain, although it does sometimes try to load the recovery files as .xlsb.
> I'm getting this bug all the time - variables that are assigned being flagged as not so. Quite often it seems that the setting of the variable is within an If..Then construct, but not always. Eg here's a very simple proc with this issue ``` Sub Tests() Dim mynmr As String Dim rng As Range mynmr = HasNamedRange(ActiveCell) Set rng = GetRangeFromNMR(mynmr) Debug.Print Intersect(rng, ActiveSheet.Cells) Is Nothing End Sub ```
This is flagged as "Variable rng is never assigned" which it
..."proper Hungarian" would have been to use, instead of e.g. intLine and intColumn, actually useful prefixes like vbLine/vbColumn and tLine/tColumn where vb denotes a 1-based coordinate, and t (for "token") denotes a 0-based coordinate
so when you go and write code against the VBIDE API and use tLine and tColumn values, you know it's wrong, because they should be vbLine and vbColumn, the 1-based values.
that's "Apps Hungarian" - the actual, real, useful Hungarian notation. it makes wrong code look wrong
sticking a type prefix to every variable was never Charles Simonyi's intent
In my pursuit of continual research it finally makes sense when, how, and most importantly the why to use it. Previously I could never find anything that remotely explained it.
/// <Summary>
/// A 1-based selection point in a code module.
/// </Summary>
public struct CodeModuleCoordinate
{
public CodeModuleCoordinate(int line, int column)
{
Line = line;
Column = column;
}
public int Line { get; }
public int Column { get; }
}
joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions in the paragraph near the bottom where it talks about 'In teaching someone about COM programming...' as well as the one above it makes sense that you can use it but you don't know why it works just that it does
^ Thus code inspections in VBA. If COM is an abstraction of the WinAPI and OLE, VBA is an abstraction of that, and then user classes are an abstraction of the abstraction.
If you know how [IUnknown](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680509(v=vs.85).aspx) and [IDispatch](https://msdn.microsoft.com/en-us/library/windows/desktop/ms221608(v=vs.85).aspx) work, then throw in a bit of [`VARIANT`](https://msdn.microsoft.com/en-us/library/windows/desktop/ms221627(v=vs.85).aspx) and [SAFEARRAY](https://msdn.microsoft.com/en-us/library/windows/desktop/ms221482(v=vs.85).aspx), you're pretty much there. The rest is syntax and window dressing.
Hmmmm... may have to do it manually then. I was thinking of putting a workbook into the test project files that kicked off a bunch of test tests in Workbook_Open and triggering it with a build action or something along those lines.
> This PR enhances name conflict discovery during Rename-Refactoring. The discovery logic now accounts for name conflicts resulting from renaming an identifier where itself, it's declaration, or another reference would cause conflicts. See also #2817.
There's currently no such thing as RDInject - I was just pointing out that it would be one of the things we'd be able to do if we can figure out how to new up VBA objects from .NET.
> Host documents and the VBA project contain pointers to each other, creating cycles. To break the cycles and shut down the document correctly, the host should call IVbaProject::Close when closing the document. VBA destroys as much of the project as possible and release as many back pointers to the host as it can. After this is done, the host document and its VBA project can be kept alive by references to it, such as running code. The host can choose to “zombie” its objects until all references to it are released. Objects that are “zombied” are those that must but cannot be destroyed, becau…
OK, so how hard can it be to answer "is this VBA or VB.NET"?
That link it to VB.NET documentation, not VBA documentation. If you opened Visual Basic from Excel, you're programming in VBA. If you opened Visual Studio and referenced the Office Interop, you're programming in VB.NET. — Comintern25 secs ago
That article was really helpful in me understanding Hungarian notation. It's original intended use, and why @Mat'sMug is so emphatic about it in his interview.
I agree, it's a good article. I liked it and get the concept even though I still find Hungarian notation helpful for myself.
I find the type reminders to be helpful even though others do not need them - it makes it easier for me to follow the title of the article ("make wrong code look wrong") even though Joel doesn't need type reminders to help him do that
and the IDE already tells you what the type of a variable is (ctrl+i) - as does RD's status bar, and you're supposed to declare variables close to where you're using them anyway, and a procedure shouldn't be large enough to not fit the screen. Really, IMO there's simply no excuse for "systems hungarian".
I'm improving right now on declaring variables close to where I'm using them - I'm in the middle of overhauling my programs with the help of your teaching on classes and the answer here: http://codereview.stackexchange.com/questions/156651/fixing-medical-claim-files-through-text-file-read-write I bet once I finish overhauling my programs Systems Hungarian will seem a lot less useful and I'll feel more comfortable agreeing with your point.
But in the meantime I might see something like prnI vrbFind sbjIt vrbMakes nCode adjHarder prTo vrbRead and think "Oh, this is breaking because I can't use two verbs in the same VBA sentence."
@IvenBach the lower limit depends on how much abstraction becomes too much abstraction. And then there's the balance between readability and performance: write code so that it's easy to read/maintain, and then optimize the performance bottlenecks. Inlining every function lowers the abstraction level and reduces (a tiny little bit of) overhead.
well, much like Application.Run supports multiple syntax forms, it seems Ribbon callbacks do too (in fact I suspect Office is just calling Application.Run behind the scenes).
All of these are valid ways of specifying a callback handler that calls Bar:
Bar
Module1.Bar
myProject.Bar
myProject.Module1.Bar
RibbonSample.xlsm!Bar
RibbonSample.xlsm!Module1.Bar
RibbonSample.xlsm!myProject.Bar
RibbonSample.xlsm!myProject.Module1.Bar
> Parameter 'myParameter' is passed ByVal and assigned a value
and this fix:
> Create and use local copy of the parameter
The fix dims a new local variable, makes it equal to the parameter, and replaces any references to that parameter with the new local variable. Great feature!
However, if the parameter is an object, for example a range, the fix does not use `Set`.
For example, applying this fix here: ``` Private Sub test(ByVal ta
@Hosch250 yep, 3 and 7, (and 1 and 5) fail if Bar is defined in more than one module.
and if Bar is defined in an add-in, but the activeWorkbook also has a procedure name Bar in Module1 and the project is also called VBAProjectmyProject, then the ribbon will call the ActiveWorkbook's declaration for 1,2,3 and 4.
but my point is, do I need to parse the callback delegate name? Is there a way to convert it into a QualifiedMemberName?
@Hosch250 yep - for Excel and Word, the Ribbon XML will normally be fixed at the time the file is opened (I think the only exception is a user customizing their Quick Access Toolbar for a workbook). And I can only read an Excel/Word customization as of the last save (so I can't read the QAT changes unless they're saved).
In theory, I only need to read the XML after a save, rather than on every parse. But some hosts allow the ribbon XML to be set at runtime, or load from an Access table that can change at design or runtime. I guess I'll make the Ribbon callbacks a property of the project and cache as necessary
en.wikipedia.org/wiki/… made no sense to me. Ater reading the article @Mat'sMug referenced. 'Systems Hungarian' vs 'Apps Hungarian' and reviewing AdvantagesDisadvantages & Notable opinions it all clicked!
> RD correctly identified the object variable mergeAreaTmp as being assigned without the 'Set' keyword in the procedure below, however this procedure compiles and runs without error and works as intended. The procedure unmerges all cells in the active workbook.
``` Public Sub UnMergeAll(Optional ByVal optionDataInAllCells As Boolean = False) Dim cellTmp As Range Dim mergeAreaTmp As Range Dim varCell As Variant
For Each cellTmp In activesheet.usedRange If cellT
> Thanks for taking the time to report this - the underlying problem is a known issue. We're currently not taking the use of the default member of object variable into account for that inspection (see #2602). Note that this should probably be triggering a different inspection, something along the lines of "Implicit use of default member Value".
VBA Rubberducking
VBA Rubberducking