It's on me though. I suck at monthly releases... I'd postpone releasing until every little bug is fixed! ...and yet I haven't committed to RD in what feels like ages, and work gets in the way, and I still need to write that book, ...and on a related note, did Max burn out?
I mean, he's been away for a while, I hope he's doing fine
My pedantry has strengthened to the point where seeing the following code makes me want to scream "CORRECT YOUR SUB NAME! IT'S NOT DELETING ANYTHING"
Sub DeleteNonActiveWorksheets()
Dim ws As Worksheet
For Each ws In ThisWorkbook.Worksheets
If ws.Name <> ThisWorkbook.ActiveSheet.Name Then
ws.Visible = xlSheetHidden
End If
Next ws
End Sub
I don't know if the extra knowledge from the pond is a blessing or a curse... I thought it was the former. Maybe later I'll consider it a latter.
Given the following code: ```vb Dim x As Something Dim y As IOtherThing
Set x = New Something Set y = x 'Uh oh, SomeThing doesn't implement IOtherThing ```
It will compile but blow up with a runtime error. In this context, the `Something` is a VBA class, and there is absolutely no reason why we can't statically infer whether the cast is valid or not, since a class would have to have a `Implements IOtherThing` in its definition.
Is it just me or with very latest pre-release is indenting only working at project (not module) level? I searched the open issues and didn't find anything.
> I am very much in favor of this inspection as this has bitten me so many times already.
The implementation should not be too hard as long as we restrict the inspection to the assignment of variables only.
A future follow up could be to extend it to the handling of arbitrary expressions on the RHS. However, that will require to implement expression type evaluation.
Just one subtle point. This inspection will also flag a case that does not cause a runtime error: assigning a variable th
> Hitting the "main" refresh button doesn't resolve the issue. After clicking it, I read on this button "Starting", then "Loading reference", "Resolving reference" and finally it display again "Ready" but in the Code Inspection window the error remain the same.
so my co-worker and i built this class that generates forms for us, right now its pretty bare bones, but it formats them, and adds in the appropriate tags based on field information
then there was a portion of the code where we would create a new form if we didnt find an existing form, based on what ive talked to you guys about, in a lot of cases, it may be better to OERM through if the form exists vs iterating through the collection till you find it, if it exists.
so i built some testing to see which was better
if there are no forms in hte collection, the very first form causes a huge slowdown on hte first test, then the rest of them normalize
so i put in like 10 forms and ran it again, that fixed the huge slowdown skewing the results, but each time i ran the test set, the time it took was roughly the same
i figured at that point, that i would need more forms in the form collection to REALLY see a difference, so i got mean, and generated 500 forms. now the differences maybe 3s or less when hte total was ~36.7s and ~39.1s
i really thought that it would be more of a difference between the two methods
though thats an aggragate of both methods of opening a form, one where it exists and one where it doesnt
500 forms felt extreme, but for how many forms were there... it didnt feel like much of a difference
Background:
For several of my workbooks I run Overview sheets with charts in them. When printing the Overview sheet, I put my workbook name as header, where the workbook name includes the criteria for the generating the source data (e.g., date range and time stamp plus non-numeric strings).
To...
You should avoid using Task.Factory.StartNew with async-await. You should use Task.Run instead.
An async method returns a Task<T>, an async delegate does as well. Task.Factory.StartNew also returns a Task<T>, where its result is the result of the delegate parameter. So when used together it retu...
or an Unwrap?
@Vogel612 you mean await Task.WhenAll instead of Task.WaitAll?
you're either going to need a countdown latch for each task to check in with or some other synchronization mechanism unless you can unwrap the tasks...
Unwrap() creates a new task instance that represent whole operation on each call. In contrast to await task created in such a way is differ from original inner task. See the Unwrap() docs, and consider the following code:
private async static Task Foo()
{
Task<Task<int>> barMarker = Bar();
...
> I am creating a class to take a collection of things and turn that collection into an array that mirrors the collection. The ultimate intent is to have a collection, transform it into an array that can then be dropped onto an Excel sheet, sort it, get the sorted array back and then convert that sorted array into a sorted collection. So, step 1> write a test to compare a prepopulated array (ExpectedResult) to a return array (result) from the class that derives the result from an initial collec
> If the function is declared to return a `Variant` but doesn't *actually* return anything, what `Assert.SequenceEquals` receives is a `Variant/Empty`... which isn't an array, hence the error message: `Assert.SequenceEquals` expects arrays, and throws an error when it's not getting them - that is by design, and expected behavior.
> *so it is expected to fail at this point until I actually write something to do the work.*
Not sure I understand what the problem is then - isn't the test faili
> Maybe we need to handle `Variant/Empty` and report it as such, with a more specific `Inconclusive` message? The adjustment would have to be made here:
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4535?src=pr&el=h1) Report > Merging [#4535](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4535?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bdef13f0747fcb0278978337d33354e2914d7e96?src=pr&el=desc) will **increase** coverage by `0.04%`. > The diff coverage is `63.25%`.
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4535?src=pr&el=h1) Report > Merging [#4535](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4535?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bdef13f0747fcb0278978337d33354e2914d7e96?src=pr&el=desc) will **decrease** coverage by `0.13%`. > The diff coverage is `63.25%`.
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4535?src=pr&el=h1) Report > Merging [#4535](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4535?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/bdef13f0747fcb0278978337d33354e2914d7e96?src=pr&el=desc) will **decrease** coverage by `0.13%`. > The diff coverage is `63.25%`.
Background:
For several of my workbooks I run Overview sheets with charts in them. When printing the Overview sheet, I put my workbook name as header, where the workbook name includes the criteria for the generating the source data (e.g., date range and time stamp plus non-numeric strings).
To...
Unwrap() creates a new task instance that represent whole operation on each call. In contrast to await task created in such a way is differ from original inner task. See the Unwrap() docs, and consider the following code:
private async static Task Foo()
{
Task<Task<int>> barMarker = Bar();
...
VBA Rubberducking
VBA Rubberducking