|
|
TheGermoz wrote:
has anyone experience of a working solution?
A few; didn't need one for the last years, but I've implemented Hunspell[^], NetSpell[^] and something called "iSpell", whose link I cannot find.
They worked as advertised.
Bastard Programmer from Hell 
if you can't read my code, try converting it here[^]
|
|
|
|
|
apparently they spell simply a text (I can use word?!), but I need to spell the comment in the code from VS
|
|
|
|
|
In that case, you'd need to get familiar with writing a VS-addin; I'd suggest trying to create a prototype for both "problems" (spellcheck a textbox, do something in VS), and working from there.
Bastard Programmer from Hell
if you can't read my code, try converting it here[^]
|
|
|
|
|
thanks it is a bit complicate, I was looking for a ready to run solution to do not reinvent the wheel.
|
|
|
|
|
TheGermoz wrote: I was looking for a ready to run solution to do not reinvent the wheel
Unless your wheel is better than the one of the competitor, no-one is going to look anyway. Ready-to-run solutions are known paths that are tried and validated.
"Where there's muck, there's money"
|
|
|
|
|
I have been using it for a while on several different computers, and always worked for me. Maybe you should add a Q & A (this is a tab on your link). Apparently somebody else if having problems: "It does work on VS 2010 Premium edition?? Im asking because i have it installed on VS 2010 Premium and it doesnt work"
|
|
|
|
|
|
I want to have a bunch of byte arrays.
They are commands which will be sent to the external device; generally across some sort of serial port (for now, at least).
I want to put them in their own file.
This is to keep the source files manageable from a human point of view.
Pretty much, 300 lines has shown itself to be a very useful generally defining limit as one of the things that helps source code make sense.
How do I put them in a file of their own which still allows them to be seen and used by the methods in the other files ?
I'm getting errors like, "The name Such_And_So does not exist in the current context".
My search for the answer lead me to a page on MSDN about "Scopes" (Found ^Here^ )
That page has what appears to be 15 rules on the scope of anything.
I tried reading a couple of those rules. In order to understand the first thing about any one of those rules, you have to already be an expert in C# to begin with (in which case, you wouldn't need the rules in front of you in the first place).
I just want to keep my source files orderly.
How do I let the methods in one file see the data packets in another file ?
The arrays will look something like this...
byte[] Command_Number___1 = new byte[] {
0xFF, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01
}
;
byte[] Command_Number___2 = new byte[] {
0x0E, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02
}
;
byte[] Command_Number___3 = new byte[] {
0xFD, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03
0x03
}
;
byte[] Command_Number___4 = new byte[] {
0xFC, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04
0x04, 0x04
}
;
byte[] Command_Number___5 = new byte[] {
0xFB, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05
}
;
byte[] Command_Number_etc = new byte[] {
0xFA, 0x0E, 0x0E, 0x0E,
0x0E, 0x0E, 0x0E, 0x0E,
0x0E, 0x0E, 0x0E, 0x0E,
0x0E, 0x0E, 0x0E, 0x0E
}
;
When I put them in a separate file, how do I make them visible to other methods which are in other files ?
It's quite conceivable (indeed normal everyday practice) that this concept will be extended to multiple functions, methods, classes, [whatever you want to call them] and variable names, constants, and who knows what else.
Perhaps the question is: How do I get the compiler and the Linker to cooperate between files ?
Whatever, whatever, thanks for the help.
|
|
|
|
|
Put them in a static class[^] of their own with static getters, and ensure they are part of the namespace of the main application.
One of these days I'm going to think of a really clever signature.
|
|
|
|
|
Richard MacCutchan wrote: Put them in a static class of their own with static getters, and ensure they are part of the namespace of the main application.
I'm trying to get an idea of all this.
Tried the following, and the code in other files still can't see the names of these groups of data bytes; no matter if I declare them as public or static...
using System;
namespace The_Same_Namespace_As_The_Other_Files
{
public partial class Form1 : Form
{
public byte[] This_Does_Not_Work = new byte[] { 0x01, 0x02 };
}
static class Class1
{
static Class1();
public byte[] The_Command_Set_01 = new byte[] {
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01
}
;
static byte[] Just_A_Test_Set = new byte[] {
0xFF, 0xFE, 0xFD, 0xFC,
0xFB, 0xFA, 0xF9, 0xF8,
0xF7, 0xF6, 0xF5
}
;
}
}
What do I need to do to let my methods in other files see the group called The_Command_Set_01 which is in this file ?
|
|
|
|
|
Your code is not addressing the values in the class. Try this:
public partial class Form1 : Form
{
MessageBox.Show("Value is: {0}", Class1.Just_A_Test_Set[1]);
}
static class Class1
{
public static byte[] The_Command_Set_01 = {
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01
};
public static byte[] Just_A_Test_Set = {
0xFF, 0xFE, 0xFD, 0xFC,
0xFB, 0xFA, 0xF9, 0xF8,
0xF7, 0xF6, 0xF5
};
}
One of these days I'm going to think of a really clever signature.
|
|
|
|
|
Aha, so the word "public" can precede the word "static" on the same line. My education continues. Obfuscation rules the world.
I just tried your idea.
In my external file which holds the command bytes (Protocol_Stuff.cs) I have these two groups...
static class Class1
{
static Class1();
public static byte[] BARN_Command_Hello = new byte[] {
0xFF, 0x00, 0x0B, 0x00,
0x11, 0x22, 0x33, 0x44,
0x55, 0x66, 0x77
}
;
public static byte[] BARN_Test = new byte[] {
0xFF, 0x00, 0x0B, 0x00,
0x11, 0x22, 0x33, 0x44,
0x55, 0x66, 0x77
}
;
}
In the file "Form1.cs" I have this...
private void button2_Click(object sender, EventArgs e)
{
MessageBox.Show("Value is: {0}", Class1.BARN_Test[1]);
}
When I choose "Build/Build", C# gives me this response...
Error 1 The name 'Class1' does not exist in the current context E:\YahYah\SoAndSo\Etc\Form1.cs 277 46 TheProgramName_03
So I say: DUH !
This is the problem that I've been trying to overcome for several days. How do I associate the stuff in one file with the stuff in another file ?
e.g., in old-fashioned low-tech anachronistic assembly language (none dare mention speed or size) I would just put...
Extern: BARN_Test ...in the file that uses it and...
Public BARN_Test ...in the file that actually holds the label. The assembler would make the space for it and the linker would put them together.
How do I do that same sort of procedure in C# with separate files ?
|
|
|
|
|
It works fine for me. Did you put the correct namespace clause in your Class1 file?
One of these days I'm going to think of a really clever signature.
|
|
|
|
|
Cancel all questions.
This post here [^] should detail the idiocy behind all this mystery.
Hopefully, I'm going to write real code now.
Thank you for loaning some brains on my behalf.
I will try my best to avoid such a blunder in the future.
|
|
|
|
|
Not quite an answer to your question, but expanding on Richard's suggestion[^] of a static class, I also recommend the getter methods generate the command, rather than hard-coding them all.
Of course, this depends on how your commands are structured. For instance, if each command includes the length of the data, or ends with a checksum or CRC, it's typically best to calculate that value and add it to the command, rather than hard-coding it.
If all of your commands are completely different and don't have any common fields like this, then ignore this post 
The shout of progress is not "Eureka!" it's "Strange... that's not what i expected". - peterchen
|
|
|
|
|
dybs wrote: If all of your commands are completely different and don't have any common fields like this, then ignore this post
Really, I don't want the send routine to be locked into sort of any formatted thing of any kind.
I want the user to click one button, and then I'll handle it from there; e.g., the number of bytes, when they are sent, etc.
The commands will be who-knows-what size, and the routine should just send out that many bytes; plus, they can change in the next version, so, I don't want format to be an issue.
I just want to do something along this line of thinking
private void Button1_Click(object sender, EventArgs e)
{
try
{
Send_This_Out_Our_Chosen_Serial_Port(The_Data_For_Button1);
return;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
|
|
|
|
|
I have a current form that is either lime or red. I think that (due to background worker threads), the best way to check the current state is to check the color of the form. How do I do this? I set it with
SetBackground(Color.Lime);
I saw the following threads, but they didn't seem to be the same thing, as far as I can tell. If it's the same, I'm not sure how to apply it to my situation.
[^]
http://www.masonmc.com/2008/getting-system-colors-in-c/[^]
|
|
|
|
|
MichCl wrote: I have a current form that is either lime or red. I think that (due to background worker threads), the best way to check the current state is to check the color of the form.
The way I read this, the forms' color determines the "state"? Usually, we keep it in a separate variable, and set the color based on that.
I'm having trouble understanding the question; am I correct in guessing that you want to "read/access" a property from a background-worker?
Bastard Programmer from Hell 
if you can't read my code, try converting it here[^]
|
|
|
|
|
I'm having trouble recording the new state because I'm on a different thread than I started on (using background worker). But I was able to set the color of the background on this thread, so I can wait until I exit the other thread, read the color of the background, and set my state variable. I've tried looking into setting variables created in different threads, but had trouble with what was suggested, and so far I've been able to avoid the issue.
For this case, I program something and have success, so I set the form color for success. Then I have to record the number of success' or failures, and that's the problem. My success/failure count and the form field it's shown in were created in a different thread. Any idea how to get the form color so I can increment my counts based on that?
|
|
|
|
|
MichCl wrote: For this case, I program something and have success, so I set the form color for success. Then I have to record the number of success' or failures, and that's the problem. My success/failure count and the form field it's shown in were created in a different thread.
Let's call that thread the mainthread or the UI-thread. The "something" you speak of, is that running in it's own thread?
You could poll a property in the form from a thread, but that requires locking -something that's always cool to avoid.
Bastard Programmer from Hell
if you can't read my code, try converting it here[^]
|
|
|
|
|
I could avoid locking and thread jumping by just querying the color of the background. Any idea how to do it?
|
|
|
|
|
You cannot; the background-color is owned by the form, owned by the mainthread.
How are you querying this value from the worker-thread? Are you polling it, checking it every so seconds?
Bastard Programmer from Hell
if you can't read my code, try converting it here[^]
|
|
|
|
|
The Control.Invoke method has an object return type and so with an appropriate delegated method any information can be obtained from a Control.
e.g.
private delegate Color ColourDelegate(Control c);
private void GetColourInfo(Control c) {
Color bgcol = (Color)c.Invoke(new ColourDelegate(GetColour), c);
Color bgcol2 = (Color)c.Invoke(new ColourDelegate(delegate { return c.BackColor; }));
}
private Color GetColour(Control ctrl) {
return ctrl.BackColor;
}
Alan.
|
|
|
|
|
MichCl wrote: I have a current form that is either lime or red. ... check the color of the form. How do I do this?
That doesn't smell right.
The color of the form should be driven the state of an object, not the other way around. It seems what you want to do is to raise an event when the status of your object changes (presumably from "good" to "bad"). Any number of observers can listen for this change and respond to it an appropriate manner.
/ravi
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
