|
|
I goofed. I was trying to say the exit code from the .EXE should not propogate up to be the exit code of the batch file itself.
|
|
|
|
|
Of course it should; unless you handle it internally, which may be the case here.
|
|
|
|
|
Could be. We know nothing of what's in the batch file.
|
|
|
|
|
And it may be the case that the EXE always returns 0. 
|
|
|
|
|
Dave Kreskowiak wrote: ExitCode doesn't work for batch files.
How so?
I ran the following test on windows 7 64 bit. I am fairly certain the following will work on any back to at least Win XP.
Batch file named DoitTest.bat, contents follow
@echo off
REM Test exit code value
exit 57
To test - open in a console window then run the following
cmd /K DoitTest.bat
echo %ERRORLEVEL%
Result is 57.
|
|
|
|
|
|
Hi,
I'm trying to keep my data access code separate from the code behind my form. What I am trying to do is populate my combo-box with a list of CompanyNames here's how I'm trying to bind this combo-box to my Companies entity to retrieve the CompanyName:
private void frmMain_Load(object sender, EventArgs e)
{
dal = new DataAccessLayer();
cmbCompanyNameSearch.DataSource = dal.GetcmbCompanyList();
}
and here's the method in my DataAccessLayer:
public List<Companies> GetcmbCompanyList()
{
if (entities == null) entities = new CompanySecretaryEntities();
ObjectQuery<Companies> companies = entities.Companies;
companies.MergeOption = MergeOption.AppendOnly;
var query = from c in entities.Companies
select c.CompanyName;
List<Companies> results = query.ToList();
return results;
}
This is giving me the following error:
Error 1 Cannot implicitly convert type 'System.Collections.Generic.List<string>' to 'System.Collections.Generic.List<CompanySecretary.Companies
Can anyone point me in the correct direction? I know if I change select c.CompanyName; to be select c; removes the error message but I only want to select c.CompanyName in this instance
|
|
|
|
|
select c.CompanyName is your problem. You are return a list of company names, not companies. Try
select c
Also the next problem you are going to have is with the ComboBox. Its only going to display the type of object "CompanySecretary.Companies". You'll need to check out the ComboBox's DisplayMember property to display the company name.
"You get that on the big jobs."
|
|
|
|
|
thank you for the reply, I have managed to get it working by changing the code behind my form to be:
List<Companies> companies = dal.GetCompanyList1();
cmbCompanyNameSearch.DataSource = companies;
cmbCompanyNameSearch.DisplayMember = "CompanyName";
cmbCompanyNameSearch.ValueMember = "CompanyID";
and renaming my DataAccessLayer method to GetCompanyList1
|
|
|
|
|
Hopefully this'll be a quick one to answer for me. I've found a process using the process class and I can use its handle to recursively process the child windows. After the recursion completes, it lists about 9 child windows. The process information's HandleCount is about 190 or so. It's possible that some information I'm looking for might be buried in those 190 handles.
Does anyone know how I can get a collection of the handles the process uses and how I can process each handle to see if its text property contains the string I'm looking for? If I can find the handle I'm looking for, I can put it in a IWin32Window object and then pass it to the OpenFileDialog constructor to ensure modality exists between it and the child form in the legacy application that needs to use it.
Putting it another way, the Process object has a HandleCount property but there's no method I can see that returns the collection of handles. If the Process object knows how many there are, it knows how to discover some information about them, no? I'd like to do something similar in my app but I can't find any appropriate methods, callbacks, etc that'll let me sit in the driver's seat. Any help appreciated.
|
|
|
|
|
Those nine windows will have sub-windows and controls. Each will have a handle - I think you'll have to loop through them using recursion.
Bastard Programmer from Hell 
|
|
|
|
|
PHS241 wrote: Hopefully this'll be a quick one to answer for me.
Handle snooping is anything but quick.
PHS241 wrote: It's possible that some information I'm looking for might be buried in those 190 handles.
It sounds as though you're trying to make the OpenFileDialog in your app a modal child window of another app. I don't see this working as "modal" is a code flow control operation, but a window ownership one.
The handles you're seeing are not just for Windows and controls. They cover LOTS of other things, like DLL's, pens, brushes, other GDI objects, files, mutexes, threads, ..., the list goes on and on.
PHS241 wrote: If the Process object knows how many there are, it knows how to discover some information about them, no?
No. You can't find a method because there is no managed code method provided to do this. There is no collection of a processes handles and no exposed methods for getting one.
Handle snooping can be done as there are already lots of tools out there that can do this. BUT, it can only be done by an Administrator account. So if you're thinking of trying this in an application used by normal users, your idea is already dead in the water.
There is no "text" property of a handle. A handle is nothing but an identifier for an object. You then have to probe the object to find out what it is. But...
This is a NASTY procedure to go through to get at the handles of a process. You can find a C example here[^], about half way down the page, a post by AdaraCD.
|
|
|
|
|
I would have posted earlier as we found a quick solution. The app that launches the app that does the open and save file dialog needed to accomodate a number of possible apps calling it. We solved it by forcing the calling app to pass the window title it wants to attach modality to. The called app then receives the form title and then calls the API function FindWindow. The handle is 0 if no window exists or non-zero if it does in which case we know the handle reference. We construct a class derived from IWin32Window and pass the handle into it. Finally, we pass that object into the open and save file dialogs constructor. When the Show method is issued by the called app, the modality ties it to the window it was initiated from and voila, it all works as required.
I spent a bit of time trying to work out handle recursion which was thankfully not needed. I guess we had to jump through the hoops as part of the process. If I remember, I'll post a code snippet tomorrow in case anyone else wants to know of a possible solution. It might not be ideal or super-efficient but it works and with customers snapping at our heels it was a good outcome. 
|
|
|
|
|
If anyone's interested here is what we did, first the issue:
We have an engineering package (off the shelf) that runs fine on XP but under some conditions hangs on 7. We isolated the problem to the open and save dialogs. We wrote an exe containing the open and save dialog controls. That worked fine, but it wasn't modal. After some research, the calling app now shells the exe and passes its window title into it. We get the handle of the form containing the title we're looking for and that gets passed into the open and save dialog controls. This establishes a modal link between caller and called exe. Without this, the exe would be launched fine but if you clicked somewhere else you lose the exe's form (it doesn't appear on the taskbar) and that puzzles the users. What we've achieved works around the 7 problem. As I alluded, it might not be ultra efficient but it works okay for us on 7 so take it or leave it! No, I cannot post the complete code but the following snippets should get you started.
1. Define the api function to get a window title:
[DllImport("user32.dll", EntryPoint = "FindWindow", SetLastError = true)]
static extern IntPtr FindWindowByCaption(IntPtr zeroOnly, string windowName);
2. Use it to get the handle of a window containing the title you're looking for. Note, IntPtr.Zero forces the search by title alone.
IntPtr ip = FindWindowByCaption(IntPtr.Zero, windowTitle);
3. Define a class deriving from IWin32Window.
internal class WindowWrapper : IWin32Window
{
private readonly IntPtr _hwnd;
public WindowWrapper(IntPtr handle)
{
_hwnd = handle;
}
public IntPtr Handle
{
get {return _hwnd;}
}
}
4. Assign the handle (IntPtr) from 2 above into an instance of WindowWrapper (3).
WindowWrapper ww = new WindowWrapper(ip)
5. Finally, use the wrapper in the constructor of the file dialog to establish a modal link between calling form and the executable.
OpenFileDialog ofd = new OpenFileDialog();
if(ofd.ShowDialog(ww) == DialogResult.Cancel) blah blah blah.
Obviously, you don't need to do this if you're using the dialogs in your own forms but it's a possible get-out-of-jail card if you need to connect disparate processes.
|
|
|
|
|
Hi all,
I am a fan of factory and interface driven development but often find myself working amongst people i do not trust to stick to such patterns. As a result i have taken to using a couple of techniques to ensure instantiation happens via factories:
1. Private nested concrete implementations
In this approach i have the default concrete implementation of an interface decalred as private nested classes within the factory an exposed as interfaces
public interface IFoo{};
private static class FooFactory
{
public static IFoo CreateFoo()
{
return new Foo();
}
private class Foo : IFoo
{
public Foo(){};
}
}
2. Protected constructors with nested subclass
I came up with this approach as i needed to work with concrete classes (due to quirks of operator overloads) but still did'nt want the classes instantiated outside of the factory. The concrete class is publicly available but has a protected constructor. within the factory is a subclass of the concrete class that makes the constructor available to the factory
public class Foo
{
protected Foo(){};
}
public static class FooFactory
{
public static Foo CreateFoo()
{
return new FooProvider();
}
private class FooProvider : Foo
{
public FooProvider(){}
}
}
What techniques do everyone use to enforce use of a singleton factory? or do you simply trust your fellow developers to do things properly?
Pedis ex oris
Quidquid latine dictum sit, altum sonatur
|
|
|
|
|
Don't. You should use factories where they're appropriate, and allow people to instantiate objects directly where that's appropriate (i.e. when you don't need dynamic/runtime type switching on the instances that are created). Overuse of factories is a classic Java anti-pattern and quite an annoying habit to work with.
C# style is generally not factory heavy, unless you actually need to pass factory objects around for some reason (for example if you want to have a self-extending collection and pass a factory to it so it can create new elements). In the vast majority of cases you just want a normal set of classes with constructors.
If people are constructing objects without using a factory, ask yourself: what is wrong with that? If there is a good answer, you should be able to explain to the other devs how their life would be easier if they used a factory. If you can't do that, you're just being dogmatic and it's you that should adapt.
Your second approach doesn't work because anyone can inherit that class and provide a public constructor. Personally I'd say you should only use protected constructors in an abstract class, because otherwise you are either hiding something that works unnecessarily, or you have a constructor which does not leave the object in a valid state, and both of those things are generally bad.
|
|
|
|
|
I understand your viewpoint but there are situations i which use of a dedicated factory is highly desirable. Some examples i've come across:
- choice of concrete class is determined at runtime based on a user-editable configuration file (think spring mappings)
- part of the construction logic requires registration to some form of catalog class and other constraints mean that it is better to have the catalog act as a factory and apply logic to the instances it creates than to have the concrete class constructor locate and register with the catalog
As for the second approach, i'm aware of the limitations with regards to exposing the constructor through inheritance (as i am aware of the option to access a ctor via reflection), however i would expect anyone finding themselves doing such things to get at a ctor to ask themselves if that class was meant to be directly instantiated. Thats what i am after (perhaps 'enforce' is too strong a word)
Pedis ex oris
Quidquid latine dictum sit, altum sonatur
|
|
|
|
|
In the first place it should be trivial to explain to other devs why they should use a factory, since otherwise their instantiation code is going to contain reflection or type-selector-switching. (So will the code inside the factory, mind, so it's not technically better that way, but it does make the user code cleaner and that should be easy to demonstrate.) This is the one case where I absolutely agree with the factory pattern (along with the self-extending-collection I mentioned before).
An alternative pattern for the second way is to pass the catalog to the constructor and have instances register themselves. I'd generally prefer that to a factory – the registration is an external linkage of the instance, not an intrinsic attribute of it, and it doesn't make sense to me to tie instances to a particular factory simply because they need to register somewhere. Factories prohibit you from subclassing the item types for customised behaviour, whereas self-registration doesn't.
Are you a converted Java developer? The mention of Spring along with the factory-centric mindset makes that seem likely to me. If so, I think you should be looking to pick up .Net habits, not enforce your Java preferences on your team.
however i would expect anyone finding themselves doing such things to get at a ctor to ask themselves if that class was meant to be directly instantiated.
Right, but if the only reason that they ask that is because you've put an arbitrary mechanism into the code that amounts to nothing more than 'because I said so', you should be asking whether there is really a good reason why they shouldn't instantiate that class directly. If there's a good reason why the class needs to be factory-spawned, there will be some awkwardness involved in using it directly that will already cause them to wonder if they are missing something.
I have written quite complex .Net applications (solo and as part of a team) and I don't think I've ever had to use a factory, apart from the runtime loading against an interface (the plugin architecture common in .Net apps is essentially grand scale IPlugin factorying, and creating DbCommands against the correct type of database). I have had the container registration thing you mention and that can be solved without a factory.
|
|
|
|
|
I get your point with regards to flexibility of use being restricted by a factory
In my most recent implementation using a factory I was implementing a system whereby properties of a viewmodel would be backed by wrapped values to provide additional functionality (history tracking, validation etc).. a lot of the data for these wrapped values was to be declared on a static field definition (thinks such as notification logic, validation rules, unit derivation information etc). Each class would, therefore, have a static field catalog holding a collection of field definitions.
From the field catalog an instance 'state manager' object could be created that exposed the value wrappers. It was these value wrappers i didn't want directly instantiated as they would not be tied to a field definition.
This could have been achieved, i suppose, by instantiating the state manger and passing ti to the wrapper's constructor, however a lot of the instantiation process is automated by having it performed as part of the statemanager initialization
I hope that gives some insight into my thinking in that scenario
As for being a java developer, i'm a c# developer but in a previous job (early in my career) i worked for a company that used both java and c# (on the same product, java back end, c# client) and fell under the tutelage of a java dev ... so i will concede i may have picked up a few java-isms along the way 
Pedis ex oris
Quidquid latine dictum sit, altum sonatur
|
|
|
|
|
GParkings wrote: Some examples i've come across:
Those are of course appropriate uses. Most cases do not apply to that.
If you have users circumventing that then education is the proper course.
Look at it in a different way if they don't know why you are doing that then they might be writing their own code in a way that is inappropriate because they don't understand the alternatives.
|
|
|
|
|
GParkings wrote: What techniques do everyone use to enforce use of a singleton factory?
I'm familiar with the pattern, but I tend to use it only when it adds value. A constructor can be found using reflection, and most programmers will be familiar with the "x = new x()" pattern. Factory-methods can't use object initializers[^], which would also count as a drawback.
Otherwise, it's always a matter of making the constructor private and doing the construction from a method. The pattern I'm using is described here[^].
Bastard Programmer from Hell
|
|
|
|
|
personally i've always preferred a suite of dedicated singleton factories (providing construction for a category of types) than individual static factory methods on each type. Thats probably personal preference though.
Pedis ex oris
Quidquid latine dictum sit, altum sonatur
|
|
|
|
|
GParkings wrote: personally i've always preferred a suite of dedicated singleton factories
(providing construction for a category of types) than individual static factory
methods on each type. Thats probably personal preference though.
Taste is a lousy argument. Either it helps during the implementation, or it doesn't.
What's the use of a factory if it merely hides the constructor? Yes, I agree that they're a nice way of moving the construction to a user-configuration, but you don't need a factory-method in every class to do so; in fact, it'd be overkill, and needless complexity. Needless complexity is usually avoided, as it makes the project harder to maintain, and increases the chance of introducing bugs.
If the programmer that's using your classes needs to use a different class based on a configuration, then he'd be the one to build a factory.
Bastard Programmer from Hell
|
|
|
|
|
I think we are getting some crossed wires here , i am actually arguing against a factory method in every class and talkign about a common singleton factory providing factory methods for a group of classes with a common association.
Also, and perhaps my initial question was a little misleading, i am not suggesting a factory approach for every class, rather, i was trying to spark a debate on how to enforce use of a factory where one is deemed nescessary/advantageous
Pedis ex oris
Quidquid latine dictum sit, altum sonatur
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
