
It's not possible to help you. We have no idea what source code you downloaded, where you got it from, what the exception message is, ... nothing.
Asking questions is a skill. You better learn how to do it.





Well how could anyone help if you do not share what issue you are facing?
modified 20Sep20 21:01pm.





Form2.cs isn't loading and once I click recognize image it throws exception errors.....
Filestream filestream =new Filestream (strong, FileMode.OpenOrCreate,FileAccess.Read)





You might want to start by learning how to ask questions. Nobody has any clue what you're talking about.
You haven't shown the code that has anything to do with "Form2.cs", nor described the context of what you're talking about.
Image? What image? What's the error message when you click the image?
What does this filestream garbage have to do with the error, if anything?
We can't see your screen or read your mind. We only get to work with what you tell you in these posts.





Hi All,
Is there any way in C# to create unique number from string ?.





It's called a "hash".
You cannot generate a unique value from a string. Since there are a virtually unlimited number of strings possible, but only a finite number of bit available to represent it's hash code, it's impossible to get a unique value. You can only generate a value that is UNLIKELY to be a duplicate from two different strings, called a "collision". The likeliness of a collision gets lower and lower with the more bits you have in your hash value.
The .NET Framework has 7 hash algorithms built into it, HashAlgorithm Class (System.Security.Cryptography)[^].





And before you ask, a hash cannot be reversed, so once the string goes out of scope, there's no way you can get it back with the hash.
".45 ACP  because shooting twice is just silly"  JSOP, 2010  You can never have too much ammo  unless you're swimming, or on fire.  JSOP, 2010  When you pry the gun from my cold dead hands, be careful  the barrel will be very hot.  JSOP, 2013





Clarify your goal; you want:
1. you want a as uniqueaspossible string : getting its source from its value is not required:
use hashing, or, use a GUID
2. you want a as uniqueaspossible string : getting its source from its value is required:
use encryption
«... thank the gods that they have made you superior to those events which they have not placed within your own control, rendered you accountable for that only which is within you own control For what, then, have they made you responsible? For that which is alone in your own power—a right use of things as they appear.» Discourses of Epictetus Book I:12





i have requirement of provide numeric value for string value. whatever number is being generated it should be unique for a string.





You are not responding to the issues raised.
Show us an example of "numeric value for string value. whatever number is being generated it should be unique for a string.":
«... thank the gods that they have made you superior to those events which they have not placed within your own control, rendered you accountable for that only which is within you own control For what, then, have they made you responsible? For that which is alone in your own power—a right use of things as they appear.» Discourses of Epictetus Book I:12





It all depends on how you define the word "number".
If a "number" has to be have the ability to be assigned to an integral value type (eg Int, uLong) then you are kind of limited; either it will need to have a maximum amount of characters (20 if using unsigned 64 bit integer) or it will have the possibility of collisions as it would need to be hashed.
On the other hand, if what is desired is just a collection of digits; then you could fabricate a sequence of numbers and stuff it into a string.
The following is whipped just whipped together, not tested and is; already known to be limited as it is ASCII based and will not do well when UTF characters are passed in. It is up to you to you to you troubleshoot, this example is only a nudge into a possible direction.
private string StringToNumberString (string inputString) {
StringBuilder OutputBuilder = new StringBuilder("");
byte[] ByteArrary = Encoding.ASCII.GetBytes(inputString);
foreach (byte SingleByte in ByteArrary) {
int ByteValue = Convert.ToInt32(SingleByte);
string ByteValueString = ("000" + ByteValue.ToString()).Right(3);
OutputBuilder.Append(ByteValueString);
}
return OutputBuilder.ToString();
}
Director of Transmogrification Services
Shinobi of Query Language
Master of Yoda Conditional





MadMyche wrote:
int ByteValue = Convert.ToInt32(SingleByte);
string ByteValueString = ("000" + ByteValue.ToString()).Right(3);
OutputBuilder.Append(ByteValueString);
 No need to convert to an
Int32  a Byte is already numeric;  No need for custom padding or extensions methods, when the builtin format strings will do the work for you;
string ByteValueString = SingleByte.ToString("D3");
OutputBuilder.Append(ByteValueString);
Standard Numeric Format Strings  Microsoft Docs[^]
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
 Homer





There certainly is. Keep a Dictionary<string, int> of strings you have encountered. The int is assigned as the Count of items in the dictionary when you add a string you haven't encountered already.
This space for rent





Absent the OP responding: let's throw some more ideas against the wall
Guid g = Guid.NewGuid();
byte[] b = g.ToByteArray();
BigInteger bigI = new BigInteger(b);
string s0 = g.ToString();
string s1 = System.Text.Encoding.Unicode.GetString(b);
string s2 = System.Text.Encoding.UTF8.GetString(b);
string s3 = System.Text.Encoding.ASCII.GetString(b);
string s4 = bigI.ToString();
Console.WriteLine($"guid to string: {s0}\r\nbyte[] to Unicode string: {s1}\r\nbyte[] to UTF8 string: {s2}\r\nbyte[] to ASCII string: {s3}\r\nbyte[] to BigInt to string: {s4}"); Sample output:
guid to string: 80e05ce58fb143d39c6aef1f69d1c07b
byte[] to Unicode string: ????????
byte[] to UTF8 string: ?\????C?j?i??{
byte[] to ASCII string: ?\?????C?j?i??{
byte[] to BigInt to string: 164496211830831038497496437204793187557
Note that converting a GUID to a Byte[] involves an ordering of the bytes many find nonintuitive: [^]
«... thank the gods that they have made you superior to those events which they have not placed within your own control, rendered you accountable for that only which is within you own control For what, then, have they made you responsible? For that which is alone in your own power—a right use of things as they appear.» Discourses of Epictetus Book I:12





Hello, I am requesting you to help me on a topic,
Indicator Device Connected to Computer with Serial Port
The following information is coming when I watch Putty
[url=https://hizliresim.com/5D6MAD][img]https://i.hizliresim.com/5D6MAD.png[/img][/url]
When I Test On C # Using the Following Codes
string GelenVeri = SerialPortKBS.ReadLine();
GelenVeri.Substring(6, 6);
listBox1.Items.Add(GelenVeri);
LBLAgirlikDurumu.ForeColor = System.Drawing.Color.Red;
LBLAgirlikDurumu.Text = "";
LBLAgirlikDurumu.Text = GelenVeri;
listBox1.SelectedIndex = listBox1.Items.Count  1;
listBox1.SelectedIndex = 1;
string ReceivedString = "";
if (SerialPortKBS.BytesToRead > 0)
{
byte[] ret = new byte[SerialPortKBS.BytesToRead];
SerialPortKBS.Read(ret, 0, ret.Length);
ReceivedString = Encoding.ASCII.GetString(ret);
if (ReceivedString.Length > 6)
ReceivedString = ReceivedString.Substring(5, 6);
LBLAgirlikDurumu.Text = ReceivedString;
}
When Weight is Weighted on a Scale Always Values Are as Below but Weight on the Indicator
Always reads the first time I read it with SerialPort.ReadLine (). Does not Show Last Value
Too Many Experiences But I Was Not Successful, Are You Help?





Even with a scale, your need to "send" before you can "receive".
And you may need to wait up to 200+ ms for a response (centering; etc.)
"(I) am amazed to see myself here rather than there ... now rather than then".
― Blaise Pascal





I have a Number class and a Polynomial class. Certain algorithms are applicable to both by virtue of the fact that both support the arithmetic operations and have additive and multiplicative identities. In order to make the algorithms available to both without code duplication, I'm trying to add a common abstract base class for them, which I'm calling ArithmeticObject. This class needs to provide, among other things, a way to access the identities. When operating on Number objects, the identities are necessarily of type Number, while for Polynomials, they are of type Polynomial. This suggests to me that I need abstract methods with return type ArithmeticObject, which Number and Polynomial each override to return the appropriate objects. On the other hand, the identities are conceptually associated with the types Number and Polynomial, not with specific instances of them, so some kind of static method seems appropriate, but abstract methods can't be static. What is the recommended way to handle this?





Giving the methods a type argument would allow me to get around making them abstract, which would allow me to make them static and avoid having to call them with respect to an instance:
static ArithmeticObject AdditiveIdentity(Type type)
{
if (type.Equals(typeof(Number)))
return Zero;
return new Polynomial(new List<Integer>());
}
static ArithmeticObject MultiplicativeIdentity(Type type)
{
if (type.Equals(typeof(Number)))
return One;
return new Polynomial(new List<Integer> { One });
}
This still leaves one annoyance, which I didn't mention in the original question: I'm going to have to cast the return value every time I call the method, to either Integer or Polynomial. Since the type of the return value is easy to predict based on the argument, it seems like there might be a way to avoid it, but I've dealt for a long time with similar issues when overloading arithmetic operators, and haven't figured out a good approach yet.





After more tinkering, though a common base class makes conceptual sense to me, I don't think I can make the details work. The algorithms that apply to both Numbers and Polynomials need to know that the objects they're acting on can be added and multiplied, so I figured I would put methods for those operations in the base class. The problem is, it shouldn't be possible to multiply a Number with a Polynomial, which rules out the obvious choice of something like
protected abstract ArithmeticObject Multiply(ArithmeticObject a);
Maybe I can do something with a generic method?
T Multiply<T>(T a);
Perhaps defining an IArithmetic<t> interface that contains all the necessary operations, and having Number and Polynomial each implement it.





I was going to suggest this, but you beat me to it.
".45 ACP  because shooting twice is just silly"  JSOP, 2010  You can never have too much ammo  unless you're swimming, or on fire.  JSOP, 2010  When you pry the gun from my cold dead hands, be careful  the barrel will be very hot.  JSOP, 2013





I have gotten the code factored and functioning using this interface method, but it does still have the minor annoyance that GetAdditiveIdentity() and GetMultiplicativeIdentity() have to be called with respect to an instance even though they don't depend on the instance  my solution for when they were base class methods doesn't seem to apply when they're interface methods. Is there some other way to make them act staticlike?
modified 2Apr18 15:02pm.





public bool IsNumber {get {return (this is Number);} }
public bool IsPolynomial {get {return (this is Polynomial);} }
"(I) am amazed to see myself here rather than there ... now rather than then".
― Blaise Pascal





@alexanderkindle
I wonder if a combination of Classes and Extension Methods would be useful ?
Note that in the 'Polynomial class, the overloaded + operator concatenates the two internal List<int> ... but, in the Extension Method 'Add for two 'PolyNomial instances, an actual addition is performed based on ordinal position ... this variation is not meant to be anything but my guessing at the functionality you want
using System.Collections.Generic;
using System.Linq;
namespace YourNameSpace
{
public interface IArithmetic<T>
{
T TValue { set; get; }
}
public interface INumber : IArithmetic<int>
{
}
public interface IPolynomial : IArithmetic<List<int>>
{
}
public interface IOperators<T>
{
T TAdd(T t1, T t2);
}
public class Number : INumber, IOperators<Number>
{
public Number(int value = 0)
{
TValue = value;
}
public int TValue { get; set; }
public static Number operator +(Number n1, Number n2)
{
Number newNumber = new Number();
newNumber.TValue = n1.TValue + n2.TValue;
return newNumber;
}
public Number TAdd(Number t1, Number t2)
{
return t1 + t2;
}
}
public class Polynomial : IPolynomial, IOperators<Polynomial>
{
public Polynomial(params int[] ints)
{
TValue = ints.ToList();
}
public List<int> TValue { get; set; }
public static Polynomial operator +(Polynomial p1, Polynomial p2)
{
Polynomial newPolynomial = new Polynomial();
newPolynomial.TValue = p1.TValue.Concat(p2.TValue).ToList();
return newPolynomial;
}
public Polynomial TAdd(Polynomial t1, Polynomial t2)
{
return t1 + t2;
}
}
public static class ArithmeticExtensions
{
public static Number Add(this Number n1, Number n2)
{
Number n = new Number();
n.TValue += n1.TValue + n2.TValue;
return n;
}
public static Number Add(this Number n1, Polynomial p1)
{
Number n = new Number(n1.TValue);
foreach (int i in p1.TValue)
{
n.TValue += i;
}
return n;
}
public static Polynomial Add(this Polynomial p1, Polynomial p2)
{
Polynomial p;
if (p1.TValue.Count == p2.TValue.Count)
{
p = new Polynomial(p1.TValue.ToArray());
for (int i = 0; i < p.TValue.Count; i++)
{
p.TValue[i] += p2.TValue[i];
}
} else if (p1.TValue.Count < p2.TValue.Count)
{
p = new Polynomial(p2.TValue.ToArray());
for (int i = 0; i < p1.TValue.Count; i++)
{
p.TValue[i] += p1.TValue[i];
}
}
else
{
p = new Polynomial(p1.TValue.ToArray());
for (int i = 0; i < p2.TValue.Count; i++)
{
p.TValue[i] += p2.TValue[i];
}
}
return p;
}
public static Polynomial Add(this Polynomial p1, Number n1)
{
Polynomial p = new Polynomial(p1.TValue.ToArray());
for (int i = 0; i < p.TValue.Count; i++)
{
p.TValue[i] += n1.TValue;
}
return p;
}
}
} Use example:
public void Teat()
{
Number n1, n2;
Polynomial p1, p2;
n1 = new Number(100);
n2 = new Number(200);
p1 = new Polynomial(1,2,3, 4, 5, 6);
p2 = new Polynomial(7,8,9);
var n3 = n1 + n2;
var p3 = p1 + p2;
var p4 = p1.Add(p2);
var p5 = p2.Add(p1);
var p6 = p1.Add(n1);
var n4 = n2.Add(p2);
}
«... thank the gods that they have made you superior to those events which they have not placed within your own control, rendered you accountable for that only which is within you own control For what, then, have they made you responsible? For that which is alone in your own power—a right use of things as they appear.» Discourses of Epictetus Book I:12
modified 3Apr18 8:55am.





Is there a constraint one can add to the type parameter of a generic method to specify that the type implements certain extension methods? If not, I wouldn't think the extension methods would be accessible to the body of the method which, barring some completely different way of structuring things, is something I think I need to be able to do. A sketch of my current solution, where the point of jumping through these structural hoops is to support Exponentiate and ExtendedGCD:
interface IArithmetic<T>
{
T GetAdditiveIdentity();
T GetMultiplicativeIdentity();
T Minus(T n);
T Times(T n);
}
struct Division<T>
{
public T Quotient;
public T Remainder;
}
interface IDivisible<T> : IArithmetic<T>
{
Division<T> EuclideanDivideBy(T divisor);
}
abstract class Number : IArithmetic<Number>
{
...
}
class Integer : Number, IDivisible<Integer>
{
...
}
class Polynomial : IDivisible<Polynomial>
{
...
}
static T Exponentiate<T>(T expBase, Integer exponent) where T : IArithmetic<T>
{
T output = expBase.GetMultiplicativeIdentity();
T baseToAPowerOfTwo = expBase;
Integer two = new Integer(2);
while (exponent.Sign > 0)
{
Division<Integer> division = exponent.EuclideanDivideBy(two);
if (division.Remainder == One)
output = output.Times(baseToAPowerOfTwo);
baseToAPowerOfTwo = baseToAPowerOfTwo.Times(baseToAPowerOfTwo);
exponent = division.Quotient;
}
return output;
}
struct ExtendedGCDInfo<T>
{
public T GCD;
public T ACoefficient;
public T BCoefficient;
public T AOverGCD;
public T BOverGCD;
}
static ExtendedGCDInfo<T> ExtendedGCD<T>(T a, T b) where T : IDivisible<T>
{
ExtendedGCDInfo<T> output = new ExtendedGCDInfo<T>();
output.ACoefficient = a.GetAdditiveIdentity();
output.BCoefficient = a.GetMultiplicativeIdentity();
output.BOverGCD = a.GetMultiplicativeIdentity();
output.AOverGCD = a.GetAdditiveIdentity();
while (!a.Equals(a.GetAdditiveIdentity()))
{
Division<T> division = b.EuclideanDivideBy(a);
T m = output.ACoefficient.Minus(output.BOverGCD.Times(division.Quotient));
T n = output.BCoefficient.Minus(output.AOverGCD.Times(division.Quotient));
b = a;
a = division.Remainder;
output.ACoefficient = output.BOverGCD;
output.BCoefficient = output.AOverGCD;
output.BOverGCD = m;
output.AOverGCD = n;
}
output.GCD = b;
output.BOverGCD = a.GetAdditiveIdentity().Minus(output.BOverGCD);
return output;
}
The most troublesome thing about this approach is that GetAdditiveIdentity and GetMultiplicativeIdentity have to be called with respect to an instance, which isn't such a big deal here, but there's some new functionality for which it's seeming like I'll have to default construct an instance for the sole purpose of getting at the identities. It also seems a bit awkward that I have to define the methods in IArithmetic for Integers even though they're already defined for Numbers, and the functionality is identical, because the return values stipulated by the interface are different, but maybe stuff like that is inevitable no matter what I do.





Ooh...constructors don't require an instance to call, so instead of guaranteeing the presence of identities using an interface somehow, I could qualify the type parameters of Exponentiate and ExtendedGCD with new(), add parameterless constructors to Number/Integer/Polynomial that return their multiplicative inverses, and get an additive inverse where necessary by subtracting the multiplicative one from itself. Or...I could if Number weren't an abstract class. I don't think the abstractness of Number is negotiable...




