Re: programming Event Logic - C# Discussion Boards

See store and retrieve image to/from sql server database[^]article, as it's addressing your issue.

The OP clearly mentioned Access as the database, yet you gave him a link to SQL Server.

try this one: OleDb - Access(MDB) storing and retrieving images

http://social.msdn.microsoft.com/forums/en-US/adodotnetdataproviders/thread/ef838689-5484-4f23-bc3b-ce11c578c524/[^]

First and the Foremost: FIGHT TO WIN

mera sirmour: sirmour.co.in

Search here on CP. You should be able to find some good examples.
A similar question[^] was answered some time ago.

Too much of heaven can bring you underground
Heaven can always turn around
Too much of heaven, our life is all hell bound
Heaven, the kill that makes no sound

Hi Friends

I'm Trying To Create A Custom Form Using System.Drawing Namespace's Classes

But I Don't Know How To Create Event Logic Such As Onclick
And I Don't Know How To Create Any Behaviors That a Visual Form Can Do.(Such as Moving , Painting,Activateing and So on).
How To Do it.
Thanks Wink | ;)

I suggest you start by making your own custom Control first. That way you can learn the answer to such questions in a 'safe environment'. There's probably plenty of guides on how to build a custom control, with its own specific events and painting.

Once you've got the hang of that, you can try at an actual form.

Thank You For Your Answer
there Are Three Basic Techniques For Creating A control.We Can
1.Inherit From An Existing Control
2. Inherit From User Control
3.Inherit From Control
Each Of Techniques Above has Advantages And Defects.I Don't Know Which Of Techniques Is better For My Solution.
I Want to Create A New Shell Like Windows Themes. Is a Reference That I Can Use It To Find Out Any Answer.

Thanks To All Answers.

Which is best depends on your situation.

1) Inheriting from an existing control. Use this approach if there already exists a control which does most of what you want, and you want to add to it and/or change some of its functionality. A lot of the standard controls in .NET allow most of their functionality to be overwritten by virtual functions, in effect allowing a great deal of customisation, building on existing blocks. It requires you to familiarise yourself with the control in question. A great advantage to this approach is that a lot of the functionality you want is already implemented and you only need to work on the parts you want added or different. How far you can go in customisation (and how easy) depends on the specific control.

2) Inheriting from UserControl allows you to begin with 'a clean slate'. It has basic functionality to help you start a new control, such as auto-scrollbars and it's a control container out of the box. You create a custom control from this typically by combining existing controls. Since you express interest in mostly changing the look of the controls, this is probably not the best for you.

3) This allows you the most power, starting from scratch. Some functionality is right out of the box, but most you're going to have to build yourself. It's very powerful, but also the most work of the three. Best suited if you are creating an entirely new control that 1) doesn't behave like an existing control, or a group of existing controls and 2) has a unique look, so it needs to do all of its own drawing. This is the most advanced of the three.

I'm guessing you're best of with method Nr 1 - inheriting from existing controls. You can override the paint event to do your own drawing. That way, you can change the looks while preserving the functionality. But it's up to you to decide.
There are plenty of articles about creating a custom control, also here on CodeProject. Look for articles like "Custom <name> control", where name is the name of an existing control, e.g. "Custom progressbar control".

Good luck!

if you merely want your form to appear different than the Form class but exhibit exactly the same behaviour you may want to look into subclassing Form and overriding the onPaint method to apply your own graphics

In my meanderings through weird code ideas, I wrote down some simple classes in C# based on the idea of "What if variables were typed based on what they returned when called, using that as what they are."

So, for example, an equation that returns a double "is" a double (or derived from DTBase(double)); a DTFunc(string) that concatenates a string based on relevant factors "is" a string (or derived from DTBase(string)) and, of course, a DTVar(int) contains and "is" an integer. (Parenthesis substituted for angle brackets)

Being as this website is about code and being that I wrote this in C#, I decided to see what other programming netizens might think of this idea, as well as the rather present idea that someone may have thought of this first.

Thanks.

modified on Friday, August 26, 2011 9:16 PM

So what's the difference from the current state of things? Confused | :confused:

Currently?

Invalid in current state of things:

C#

double a = new Func<double>(delegate() { 2 + 2; });

Granted, a very simple example, but it helps lay the groundwork for the second example.

Valid in my Dynamic-Typed paradigm:

C#

DTBase<double> a = new DTFunc<double>(delegate() { 2 + 2; });
Console.WriteLine(a.Call); // Output 4
a = (DTVar<double>)5; // Conversion needed because DTBase<double> is an abstract class.
Console.WriteLine(a.Call); // Output 5
// Equivalent of "1 + 1 = X", where DTEquation calculates "x".
DTBase<double> a = new DTEquation((DTVar<double>)1, new DTOperand[] { new DTOperand(MathOp.Add, (DTVar<double>)1) });
Console.WriteLine(a.Call); // output 2

And in that equation, I could have put any type derived from DTBase(double), including functions, dice rolls, or, yes, other equations.

So not *quite* the current state of affairs. Smile | :)

For the amusement and edification of any readers - What may be the first actual DynamicTyped program (if someone else didn't yoink the idea first)

Provided simply to provide actual code, it accepts a sequence of numbers and outputs a formatted string:

C#

DTFunc<double, string> f = new DTFunc<double, string>(
                a =>
                {
                    string r = "";
                    while (a.Count > 0)
                    {
                        r += a.Call + ", ";
                    }
                    return r.Length > 0 ? r.Substring(0, r.Length - 2) : r;
                }
            );

            for (int i = 0; i <= 10; ++i)
                f.Args.Add = i;

            Console.WriteLine(f.Call);

Output: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Now, if I change its arg type to DTBase(double), I could feed all kinds of things into there - Variables, equations, dice rolls, other functions, file reads (not currently, but potentially)...So long as they all returned a double when called.

Reading this code I don't have a clue what you are doing: the function(?) 'Call is not shown, the meaning of 'Args' is opaque.

"In the River of Delights, Panic has not failed me." Jorge Luis Borges

Essentially? Adds the numbers 0 to 10 to the functions' arguments. The function then iterates through those arguments and constructs a comma-separated string.

"Call" is a general property that returns "Whatever it is the object does/is". In the case of the function, it calls the function. In the case of DTArgs, it dequeues the next argument.

In comment-o-vision:

C#

// So, create a new function taking DTArgs<double> as input,
// which is in short a queue of doubles (or anything else we want)
// The first type, in this case "double", is the type used by
// the function's internal DTArgs<T>.
DTFunc<double, string> f = new DTFunc<double, string>(
    a =>
    {
        // The function body.
        string r = "";
        // While our DTArgs<double> 'a' has values,
        while (a.Count > 0)
        {
            // Add the next argument to the string, followed by a comma.
            // a.Call dequeues and returns the next argument.
            r += a.Call + ", ";
        }
        // Chop off the last comma.
        return r.Length > 0 ? r.Substring(0, r.Length - 2) : r;
    }
);

// The function needs arguments,
for (int i = 0; i <= 10; ++i)
    // So add them. Granted, setting a property is not standard.
    // But, this code is in my "StrangeTest" project.
    // .Args is a property accessor to the functions' DTArgs.
    f.Args.Add = i;

// Call the function and write the output to the console.
Console.WriteLine(f.Call);

I have no idea how well I'm explaining things (which tends to make my explanations rather...Bad), but hopefully I've cleared up at least a little confusion. Smile | :)

How is that different than "var"?

Valid in current paradigm:

C#

var a = 5.5;

Invalid in current paradigm, but valid if paradigm theoretically adopted by C#:

C#

a = new func<double>(delegate() { return 5.5; });

Using a theoretical library of additional functions, both are valid:

C#

DTBase<double> a = (DTVar<double>)5.5;
a = new DTFunc<double>(delegate() { return 5.5; });

The key point is that, instead of being a specific type of variable, "a" is now defined by what you get when you call it.

And here is a heavily-commented "Guess My Number" game using this paradigm (granted, it's not runnable without the classes, but it is heavily-commented. Should I release that code? I've no idea if anyone is the least bit intruiged):

C#

// A simple "Guess my number" program.

            // The length of the number to guess.
            DTVar<int> length = 7;
            // A starting phrase.
            Console.WriteLine("Guess my Number, a {0}-digit number.", length);
            // True if or when the player guesses entirely correctly.
            DTVar<bool> allCorrect = false;
            // A function that matches the output of two DTArgs<char> arguments,
            // and returns a string with X's in all locations where they don't match.
            DTFunc<char, char, string> matchingF = new DTFunc<char, char, string>(
                (a, b) =>
                {
                    // Our return string.
                    string r = "";
                    // If our first DTArgs<char> has values remaining,
                    while (a.Count > 0)
                    {
                        // We can call a DTArgs to return the next argument,
                        // or we can convert it.
                        // As DTBase<T> works on the principle that
                        // the thing is what it returns when called,
                        // the conversion can be implicit.
                        // A DTArgs is an argument queue, essentially.
                        char a1 = a;
                        char b1 = b.Call;

                        // If the two characters match, add that character to the string.
                        // if they don't match, add 'X' to the string.
                        r += (a1 == b1 ? a1 : 'X');
                    }
                    return r;
                }
            );
            // A function to generate a new "phone number".
            DTBase<string> numberF = new DTFunc<string>(
                delegate()
                {
                    // Stores "length" number of random integers from 0 to 9 in a string.
                    string r = "";
                    // "length" may be a DTVar<int>, but because the use is unambiguous,
                    // it can use implicit conversion.
                    for (int t = 0; t < length; ++t) r += Rand.Next(10);
                    // Returns the string "phone number".
                    return r;
                }
            );
            // A function to read a new guess from the console.
            DTBase<string> guessF = new DTFunc<string>(delegate() { return Console.ReadLine(); });
            // A function to checks if the first string argument is correct by
            // checking to see if it contains a 'X'.
            // Only one argument should be entered at a time.
            DTFunc<string, bool> correctF = new DTFunc<string, bool>(a => { return !a.Call.Contains('X'); });


            // Get our number to guess.
            DTVar<string> number = numberF.Call;
            // The maximum number of guesses allowed.
            int count = 20;
            do
            {
                // We call the guess function to get the player's next guess.
                DTVar<string> guess = guessF.Call;

                // We can either call or convert the number and the guess,
                // either works.
                // DTArgs<T>.AddRange can be given an IEnumerable to add
                // everything in the enumerable to the arguments.
                // In this case, DTArgs<T> is DTArgs<char> and the
                // IEnumerable is a string.
                matchingF.Args1.AddRange = number.Call;
                // We could just call "guessF" here, but that might be
                // too ambiguous for the reader.
                matchingF.Args2.AddRange = (string)guess;

                // Likewise, we can convert-call the matching function,
                // now that it has proper arguments.
                DTVar<string> result = (string)matchingF;

                // Add the result string to the arguments of the function
                // that checks if the result string is entirely correct,
                // then store that value in "allCorrect".
                // As "allCorrect" is a DTVar<bool>, we can use implicit
                // conversion.
                // Again, we could directly store "matchingF" in the args,
                // (that is, its call).
                correctF.Args.Add = result;
                allCorrect = correctF.Call;
                
                // Write the result to the console.
                Console.WriteLine(result.Call);
            } while (!allCorrect && --count >= 0);

            // Win/lose output.
            Console.WriteLine("You {0}", (allCorrect ? "Win! :)" : "Loose. :("));

Hi Narf,

I think this kind of experimentation is a very cool thing to do: at a minimum you will come to a greater understanding of what the language limits are, and your creativity is definitely showing here !

I don't have the 'bandwidth' or inclination to study your code and figure out what you are doing, but it seems to me that you are moving C# one step past 'var' and 'dynamic' towards behaving like more loosely-typed languages (Haskell ? Ruby ?).

For me there's so much built-in to .NET in its current highly-evolved state, that I am going to stick with it, as is ... and it's evolving rapidly.

If I want a List of integers converted to a string, (as early as .NET 2.0, I believe), I can use Linq like this: (and there may well be a simpler way: I'm no expert on Linq):

List<string> s = new List<int> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.ConvertAll(i => Convert.ToString(i));

So, please do, keep going, follow your vision ! Don't let those who 'don't get it' phase you in the least Smile | :)

best, Bill

"In the River of Delights, Panic has not failed me." Jorge Luis Borges

modified on Monday, August 29, 2011 11:34 PM

I think there is an interesting discussion to be had here but I don't quite see what you are gaining over a Func<double> (with DTFunc<T>), or just a normal variable with DTVar.

I apologize if you did read this particular post, but it sounds like you didn't, so I'm reposting it.

<quote>
Valid in current paradigm:

C#

var a = 5.5;

Invalid in current paradigm, but valid if paradigm theoretically adopted by C#:

C#

a = new func<double>(delegate() { return 5.5; });

Using a theoretical library of additional functions, both are valid:

C#

DTBase<double> a = (DTVar<double>)5.5;
a = new DTFunc<double>(delegate() { return 5.5; });

The key point is that, instead of being a specific type of variable, "a" is now defined by what you get when you call it.

If you're wondering what use being able to type variables by what they return when "called" is, a few suggested thoughts are:

C#

Dictionary<string, DTBase<double>> formulasForGame; // Functions, equations, single variables and file reads.

C#

List<DTBase<string>> urlRetrieval; // Retrieves urls from various places and sources. Optionally, a list of DTArgs<string>.

C#

List<DTFunc<string, string>> chatRelays; // A set of functions that relay text strings for chat according to the specific sending needs of each specific receiver and sender.

And any other situation where you want a generic, quick way to access data by type, not implementation. That is to say, counting double and Func(double) as separate implementations, but the same type.

Thank you for your patience and interest. Smile | :)

This:

a = new func<double>(delegate() { return 5.5; });

... may be invalid if you declare a as double, but if you want this kind of flexibility, surely you can use Func<double> in most cases (and when you want a constant, write a lambda or anonymous delegate to return it, as here).

I guess that is possibly useful in some cases though.

What is the performance hit like on this? You are adding a lookup (or method call) each time the 'variable' is referenced?

Have you considered:

public implicit operator T(DTBase<T> val) { return val.Value; }
public implicit operator DTBase<T>(T val) { return new DTVar<T>(val); }

That would make your implementation almost transparent.

are you suggesting implicit casting of Func<t> instances to T? or perhaps 'implicit resolving' would be a better term.

Implicitly storing anything that returns T when "called", in T.

I believe that is simply alternative semantics to what i said Poke tongue | ;-P

but its getting late now and the caffeine is wearing off so i can't be sure ..... my brain hurts