well one problem without much work-around, is everything that's late-bound
i.e. we need to literally interpret the code to resolve the type
other than that, RD knows everything about anything that's early-bound. I mean everything.
latest released resolver works with roughly ~50K declarations in I don't even know how many scopes, just for a basic Excel VBA project with an empty UserForm and no code anywhere
@BrandonBarney we're loading the COM libraries a project references, and scrape everything we can from them. That takes a little more than a second - that's what's going on when parser state says "loading references"
I can't even see that image but I am 90% sure I've done more shameful things haha
@Comintern I think it was you that explained to me about models. And now here I am testing something, and I needed to change a Max value from 20,000 to 1,000 for testing purposes, and I was able to change a single number rather than rewriting it in a ton of places. Basic programming stuff, but so so appreciated.
Basically I did an Xlup to find the grand total row, and then kept trying .Offset(i,0).ShowDetail. This all being wrapped in an On Error Goto Err, Resume where i would increment by 1.
And I definitely have done worse lol. For this project I stored literally all of the data I was compiling on separate worksheets.
> 2.0.13 and VBA 6.5 On Fri, Apr 28, 2017 at 2:21 PM Mathieu Guindon <notifications@github.com> wrote:
> Which version are you running? > > — > You are receiving this because you authored the thread. > Reply to this email directly, view it on GitHub > <https://github.com/rubberduck-vba/Rubberduck/issues/2993#issuecomment-298071020>, > or mute the thread > <https://github.com/notifications/unsubscribe-auth/AYKNc3WZZDFxy39A5fQUlQboAWeUgNfKks5r0i4wgaJpZM4NLqcw> > . >
> @retailcoder I think we can put them on another channel outside the lexer. The CommonToken has a settable field for the channel. So I think we can rewrite the channel during preprocessing.
namespace Rextester
{
public class Program
{
class Base
{
}
class Derived : Base
{
public override string ToString()
{
return "Base";
}
}
public static void Main(string[] args)
{
Base a = new Base();
Base b = new Derived() as Base;
Derived d = new Derived();
if (b != null)
{
Console.WriteLine(a.ToString()); //expected result: GOOD! (Rextester.Program+Base)
but basically the CLR is cheating a bit, and a struct gets allocated on the stack, while reference types get allocated on the heap. but that's low-level memory management stuff that you don't need to care about
basically an Int32/int isn't allocated the same way a string or Worksheet is
So, if I understand correctly, the reason why ComInterop is so messy and a pain is because we have to deal with memory management ourselves, whereas without InterOp the memory is managed automatically?
So it's declared as Base b = new Derived() as Base; which means it should be the base type? but it's actually the derived? Because of it's run-time type?
you know, sometimes I feel about C# the same way I feel about French: I know how it works, but I can't quite explain the rules and I get confused when trying to.
First it makes me enclose my parameter in parentheses for an insert statement, (?), but then it makes me leave out the parentheses at the beginning and end of my parameter text. Give me a break, just pick one or the other.
You can't - that's entirely deliberate, as that's what polymorphism is all about. Suppose you have a derived class which enforces certain preconditions on the arguments you pass to an overridden method, in order to maintain integrity... you don't want to be able to bypass that validation and corr...
you can generate dynamic method to make proxy that use Call (not CallVirt) instruction
var x = new C();
var m = typeof (A).GetMethod("M");
var dm = new DynamicMethod("proxy", typeof (void), new [] {typeof(C)}, typeof (C));
var il = dm.GetILGenerator();
il...
(not for the faint of heart!)
This is clever, but if I saw this being used in production code to work around a limitation of architectural design, it would certainly raise my eyebrows. — Dan BryantJul 31 '10 at 14:36
rstVal.State, adStateOpen, rstVal.EOF, and rstVal.BOF are all True rstVal.Recordcount is -1
The relevant part of my parameterized query (cmd.commandtext) is: create table #DRS1(RejectedClm nvarchar(30) primary key); insert into #DRS1 values (?);
The relevant part of my parameter-inserted query (Replace(cmd.CommandText, "?", cmd.Parameters("parClaimsToQueryThisRun"), , , vbTextCompare)) is: create table #DRS1(RejectedClm nvarchar(30) primary key); insert into #DRS1 values ('N027FLP00530'),('P079FL832721'),('P079FL832714');
Oh, my chat formatting didn't get picked up, sorry
Duh check: In terms of using & or && in boolean checks the && is preferred because of it's ability to short circuit. Otherwise there's no difference between the two?
@Mat'sMug Why, because I'm using multiple values in one parameter? If so, thanks for helping me rubberduck, that was my guess after talking with you above.
@Mat'sMug And I appreciate my company's approach that we're dealing with very sensitive healthcare information so they minimize unnecessary permissions as much as possible. They can't give sandboxes to every single person who uses my programs.
BTW they don't need to give a sandbox to everyone at all
but you need to be able to pull data overnight and populate the tables you need to get your queries to run in a decent amount of time
they're not the ones wasting their time staring at their screen while the server works harder than it needs to
3 minutes per day means 15 minutes per person per week. if 4 people need to run that report it's a whole hour every week, lost to a poor query. average that to $40, times 50 weeks: the company is paying $2K/year for people waiting for that query to finish.
getting it to run in under 10 seconds won't cost anything
@Mat'sMug Well said. I just talked to some of our IT partners and they helped come up with my favorite solution yet. I can write my entire list of claims (>20k) to a text file, call a new stored procedure that would load the list into a table, and then work from there. They can set up a table on their own schema and a stored procedure I would write without bothering anyone bureaucratically. I'm optimistic again that this is going to work.
I'm sure it will be harder than I imagine, especially if the server will only report back that it triggered the stored procedure rather than it finished loading every claim in the list.
@BrandonBarney Placing an add-in on a network share is doable. Workbooks that refer to the network location store the UNC path internally (rather than a drive-lettered path), which might actually help in an environment where people use different drive letters, or don't all have the right drive mapped.
but 2 key things to keep in mind. 1. Make the add-in read-only, and then you can update the add-in whenever you like and without first having to ask everybody to close Excel.
2. Some "power-users" will make a local copy ( to make Excel load faster), and because Excel will see the correct add-in Name (even though it is on the C drive), it will treat that C drive copy as a perfect substitute for the network copy. Pretty soon, the local addin is out of sync with the network addin. You may want to put some code in the add-in that checks that the add-in is being opened from a certain location, or that the workbooks check that the addin in use is a certain version
@BrandonBarney The best solution is to have the add-in deployed, but that limits your flexibility around urgent fixes etc. The network approach is also robust, but doesn't always work if a user is on a laptop and not connected to the network.
I rolled an updater that would check the network for newer versions when it loaded. Took a while to catch all the edge cases, but eventually worked nicely.
I have "power users" in my office that consistently break the rules, then blame me when it blows up. But they also blame me when I put safeguards in place.
There's a famous story about a tier 1 asking the user to remove the power cable from the socket, "because network issue", which the user questioned, but did anyway. When the user plugged the cable back in, the tier 1 says "Great, Now I know you've actually restarted, and not just told me that you restarted"
5
@Mat'sMug IDK, it might be registerable, but for this task a single entry point is fine. The add-in is supposed to be a UI-based add-in for most users. I just want to expose some of the functionality as an API to the power-users. i.e. It wasn't supposed to be an RD suggestion, just an FYI for an easily deployed add-in architecture.
you can generate dynamic method to make proxy that use Call (not CallVirt) instruction
var x = new C();
var m = typeof (A).GetMethod("M");
var dm = new DynamicMethod("proxy", typeof (void), new [] {typeof(C)}, typeof (C));
var il = dm.GetILGenerator();
il...
VBA Rubberducking
VBA Rubberducking