Could not load file or assembly 'Newtonsoft.Json, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b9a188c8922137c6' - C# Discussion Boards

30-Jun-17 15:25

fyi: System.Drawing.Color.Red has:

'IsKnownColor and 'IsNamedColor properties : 'true

Can you predict the results of the comparisons in this code ?

public void ColorChallenge()
{
    int rval = Color.Red.ToArgb();  // Int32 => -65536

    Color clr = Color.FromArgb(rval);
    
    bool ismatchEq1 = Color.Red.Equals(clr);
    
    bool ismatchEq2 = Color.Red == clr;
    
    bool ismatchEq3 = rval == clr.ToArgb();
    
    bool isknown = clr.IsKnownColor;
    
    bool isnamed  = clr.IsNamedColor;
}

And for extra dollops of delicious pro-social goodness, predict the Type of the variable 'hx stored in 'hxtype:

public void ColorChallenge2()
{
    int rval = Color.Red.ToArgb(); // -65536
    string hex = $"0x{rval:X8}";   // "0xFFFF0000"
    
    var hx = 0xFFFF0000;
    
    string hxtype = hx.GetType().Name;
}

Notice anything interesting ?

«Beauty is in the eye of the beholder, and it may be necessary from time to time to give a stupid or misinformed beholder a black eye.» Miss Piggy

modified 30-Jun-17 22:10pm.

Eddy Vluggen1-Jul-17 0:31

Eddy Vluggen

1-Jul-17 0:31

BillWoodruff wrote:
Can you predict the results of the comparisons in this code ?

No, but I can guess. A Color would be a struct (even the "Red" property is a struct), and you are comparing that to an integer. If I "ToString" a color, I'd get a description of that color in a non-ARGB format. Makes me wonder how the comparer is implemented Smile | :)

BillWoodruff wrote:
And for extra dollops of delicious pro-social goodness, predict the Type of the variable 'hx stored in 'hxtype:

Hx would be a value-type, and I'd guess it would have to be something like a dword. ..which .NET does not have Big Grin | :-D

I can predict, without trying, that the example cannot be compiled on my machine, due to the format-string syntax in the second example Roll eyes | :rolleyes:

--edit
Just gave it a try; var has its uses, among obfuscation. That last part works.

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

modified 1-Jul-17 9:58am.

BillWoodruff2-Jul-17 14:53

2-Jul-17 14:53

Eddy Vluggen wrote:
you are comparing that to an integer.

Nope ... only same types are compared. While both Integer and Color are structs, trying to compare them will make a compile-time error.

Eddy Vluggen wrote:
Hx would be a value-type, and I'd guess it would have to be something like a dword.

Well, yes it's a value-type, but, it's 'uint. For details on the hack you need to use to work around that, please see my response to Harold Aptroot below.

Eddy Vluggen wrote:
format-string syntax in the second example

[^] C# 6 string-interpolation has some very powerful facilities of particular interest if you need to deal with multiple languages/CultureInfo.

cheers, Bill

«Beauty is in the eye of the beholder, and it may be necessary from time to time to give a stupid or misinformed beholder a black eye.» Miss Piggy

Eddy Vluggen3-Jul-17 23:30

Eddy Vluggen

3-Jul-17 23:30

Cool, been using that "simple" thing for a long time now; learned something new about Color Big Grin | :-D

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

harold aptroot2-Jul-17 2:34

harold aptroot

2-Jul-17 2:34

Yep, Color is weird. A lot of it has to do with the fact that it isn't just a wrapper around int as one might as expect. At least that's what I expected when I first met System.Drawing.Color, because what else could/should it be?

Turns out it has a bunch of weird members:

private readonly string name;
private readonly long value;
private readonly short knownColor;
private readonly short state;

BillWoodruff2-Jul-17 14:35

2-Jul-17 14:35

Right on Harold ! The fact that

bool colorweirdness = Color.FromArgb(Color.Red.ToArgb()) != Color.Red;

results in 'true gives the game away.

And, the strange "automatic conversion" to 'uint that happens in the second "challenge" is perplexing, with the only remedy being a hack like this:'

public static int HexStringToUnchecked(string hex)
{
    return unchecked(Convert.ToInt32(hex, 16));
}

«Beauty is in the eye of the beholder, and it may be necessary from time to time to give a stupid or misinformed beholder a black eye.» Miss Piggy

harold aptroot2-Jul-17 15:07

harold aptroot

2-Jul-17 15:07

The hex thing is just a funny rule about "maybe out of range depending on how you look at them" integer literals, here's a simpler remedy:

int red = unchecked((int)0xFFFF0000);

Still annoying because it needs the "unchecked" (as if I didn't know I was casting something out-of-range, that's the entire reason for casting!), also annoying (but for different reasons) are:

int red = 0xFFFF << 16; // might be alright
int red = ~0x0000FFFF; // less obvious
int red = -0x00010000; // even less obvious

.. of course none of those generalize to arbitrary colors

Or perhaps more reasonably, but requiring a time machine: ToArgb and friends should have worked with uint. Problem solved, colours are more unsigned than signed anyway (I mean when do you ever think of white as -1?), inb4 "but CLS compliance".

BTW putting (un)checked around a function call doesn't do anything. It changes the codegen for primitive operations in its "scope", so it's not something that can be imposed on a callee.

BillWoodruff2-Jul-17 19:21

2-Jul-17 19:21

Thanks, Harold,

Right now, the only way I can get back the "full" Color structure ... with fields 'NamedColor, etc., is to do a look-up in the KnownColor enumeration 'Values collection for matching integer values ... and that may result in more than one match : for each match the 'Key will be the full Color structure.

Will post code on request.

Seems like there should be an easier way to do that !

cheers, Bill

«Beauty is in the eye of the beholder, and it may be necessary from time to time to give a stupid or misinformed beholder a black eye.» Miss Piggy

Richard Deeming3-Jul-17 1:35

Richard Deeming

3-Jul-17 1:35

Are you trying to serialize the Color? That's the only time I can think of that you'd need to do this.

The obvious solution would be to combine IsKnownColor[^], ToKnownColor[^] and FromKnownColor[^]; and also IsNamedColor[^], Name[^] and FromName[^].

public struct ColorDetails : IEquatable<ColorDetails>
{
    private ColorDetails(KnownColor knownColor, string name, int argb)
    {
        KnownColor = knownColor;
        Name = name;
        Argb = argb;
    }
    
    public KnownColor KnownColor { get; }
    public string Name { get; }
    public int Argb { get; }
    
    public static ColorDetails FromColor(Color color)
    {
        if (color.IsKnownColor)
        {
            return new ColorDetails(color.ToKnownColor(), null, color.ToArgb());
        }
        if (color.IsNamedColor)
        {
            return new ColorDetails(0, color.Name, color.ToArgb());
        }
        
        return new ColorDetails(0, null, color.ToArgb());
    }
    
    public Color ToColor()
    {
        if (KnownColor != 0)
        {
            return Color.FromKnownColor(KnownColor);
        }
        if (Name != null)
        {
            return Color.FromName(Name);
        }
        
        return Color.FromArgb(Argb);
    }
    
    public override int GetHashCode()
    {
        return Argb;
    }
    
    public override bool Equals(object obj)
    {
        return obj is ColorDetails && Equals((ColorDetails)obj);
    }
    
    public bool Equals(ColorDetails other)
    {
        return Argb == other.Argb;
    }
    
    public static bool operator ==(ColorDetails left, ColorDetails right)
    {
        return left.Equals(right);
    }
    
    public static bool operator !=(ColorDetails left, ColorDetails right)
    {
        return !left.Equals(right);
    }
}

ColorDetails cd = ColorDetails.FromColor(Color.Red);
Color clr = cd.ToColor();

bool ismatchEq1 = Color.Red.Equals(clr); // True

bool ismatchEq2 = Color.Red == clr; // True

bool isknown = clr.IsKnownColor; // True
    
bool isnamed  = clr.IsNamedColor; // True

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

BillWoodruff3-Jul-17 2:51

3-Jul-17 2:51

Hi Richard,

Yes, I'm messing around with creating a Color extension for Yoshifumi Kawai's MessagePack open-source serializer: [^].

The speed and memory efficiency of MessagePack (which has optional built-in LZ4 compression) is, imho, remarkable.

I came up with something similar to your code, and implemented the required MessagePack 'Formatter and 'Resolver structures, but it had incredibly poor (slow) performance. So, I fell back on just making a simple class that saves a Color as either an integer, or a KnownColor name (string): this (excerpt) will give you an idea of what's going on:

[MessagePackObject]
public class MPColor
{
    [Key(0)] public Int32 _colorAsInt32 = -1;

    [Key(1)] public String _colorName = String.Empty;

    public MPColor()
    {
    }

    public MPColor(Color color)
    {
        MColor = color;
    }

    [IgnoreMember]
    public Color MColor
    {
        set
        {
            if (value.IsKnownColor)
            {
                _colorAsInt32 = -1;
                _colorName = value.Name;
            }
            else
            {
                _colorName = String.Empty;
                _colorAsInt32 = value.ToArgb();
            }
        }

        get
        {
            if (String.IsNullOrEmpty(_colorName))
            {
                if (_colorAsInt32 == -1)
                {
                    return Color.Empty;
                }

                return Color.FromArgb(_colorAsInt32);
            }
            
            return Color.FromName(_colorName);
        }
    }
}

This is quite fast and memory efficient. Since the KnownColor enumeration includes System Colors, that removes the need to store one aspect of state.

Tomorrow, I will study your code in depth, possibly try it out with the required 'Resolver and 'Formatter components in MessagePack.

As ever, really appreciate your quality responses !

cheers, Bill

«Beauty is in the eye of the beholder, and it may be necessary from time to time to give a stupid or misinformed beholder a black eye.» Miss Piggy

modified 3-Jul-17 9:56am.

printing an string data.

rahul199529-Jun-17 20:21

rahul1995

29-Jun-17 20:21

i am printing a string through printer as the string length is more it is not getting printed properly so i have tried to split the string and the printing but it is showing error at run time

error:ex = {"Index and length must refer to a location within the string.\r\nParameter name: length"}

for (int i = 0; printstr != null; i++)
{

if (limit >printstrlength)
{
printstr = actualstring.Substring(startindex, printstrlength);
e.Graphics.DrawString(printstr, f1, Brushes.Black, new Point(x, y));
break;
}
else
{
printstr = actualstring.Substring(startindex, limit);
e.Graphics.DrawString(printstr, f1, Brushes.Black, new Point(x, y));
}
y += 20;
startindex = limit + 1;
limit += 40;

}

OriginalGriff29-Jun-17 20:34

OriginalGriff

29-Jun-17 20:34

What it is saying is that when you try and do the Substring, the start index (or the start index plus the length of the bit you want to extract) must fit within the input string, and the numbers you have passed do not fit that criteria.

Use the debugger to look at the string and the values you pass to Substring and you should see which is wrong, and that should lead you to why it's wrong.
We can't do that for you - we don't have access to your strings!

Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
AntiTwitter: @DalekDave is now a follower!

Richard MacCutchan29-Jun-17 21:36

Richard MacCutchan

29-Jun-17 21:36

startindex = limit + 1;
limit += 40;

You are increasing limit by 40 each time round the loop. But you are also using this value to specify the length parameter in your call to actualstring.Substring(startindex, limit);, so sooner or later it will exceed the length of the remaining characters in the original string. You need to use a calculated value for the length, which starts at 40 but checks how many characters are still to be printed, each time round.

bindumol L29-Jun-17 21:53

bindumol L

29-Jun-17 21:53

I have tried this but i didn't get the error you mentioned.

private void button1_Paint(object sender, PaintEventArgs e)
        {
            string printstr = "the string length is more it is not getting printed properly so i have tried to split";
            string actualstring = "i am printing a string through printer as the string length is more it is not getting printed properly so i have tried to split the string and the printing but it is showing error at run time ";
            int printstrlength = printstr.Length;
            int limit = 10;
            int startindex = 0;
            int x = 2;
            int y = 5;
            for (int i = 0; printstr != null; i++)
            {
                if (limit > printstrlength)
                {
                    printstr = actualstring.Substring(startindex, printstrlength);
                    e.Graphics.DrawString(printstr, button1.Font, Brushes.Black, new Point(x, y));
                    break;
                }
                else
                {
                    printstr = actualstring.Substring(startindex, limit);
                    e.Graphics.DrawString(printstr, button1.Font, Brushes.Black, new Point(x, y));
                }
                y += 20;
                startindex = limit + 1;
                limit += 40;

            }
        }