|
Check your C# version - the syntax Foo(out type varName) was only added at C#7.0
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
|
|
|
|
|
Thanks for your answer. It was a version issue.
ooooo
|
|
|
|
|
You're welcome!
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
|
|
|
|
|
Complex class from Numerics does not have any Parse method
How to write parse method
public static bool TryParse(string s,out Complex z)
{
}
|
|
|
|
|
And?
What have you tried?
Where are you stuck?
What help do you need?
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
|
|
|
|
|
Member 15634071 wrote: in CE (Central Europe) where I live it is comma
Yes, that makes it 'interesting' if parsing the (a,b) format as you have no idea whether the ',' is a dec point or a value separator. e.g. (1,2,3,4) could only be 1.2+3.4i but (1,2,3) could be 1.2+3i or 1+2.3i  Just to make it even more fun, US / UK / other countries have numbers where a comma can be a thousands separator e.g. (234.567,999,888.000) could be one of several complex numbers. e.g. 234.567+999888.0i, 234.567999+888.0i, or 234.567999888+0i.
Have you looked at how Point objects are parsed (they too can have an (x,y) format where x and y are decimal numbers)?
|
|
|
|
|
Can you write en example ?
Normally not in the comment section
|
|
|
|
|
Normally, we don't give working answers, just rough pointers. However, I had wanted to create a Point.Parse() / Point.TryParse() for a different project, but had not got around to it; so this was a good excuse to write one .
This version allows (x-yi) and (x-yb) as well as your formats plus you can use (x, y) [with a space after the real/imaginary separator] to disambigute for cultures that use ',' as a decimal point.
My basic functions look like:
public static class Complex2
{
public static Complex ComplexParse(string text)
{
string[] parts;
string parsedText = text.Trim();
if (parsedText.StartsWith("(") && parsedText.EndsWith(")"))
{
parsedText = parsedText.Substring(1, parsedText.Length - 2).Trim();
if (parsedText.Contains("+") && (parsedText.EndsWith("i") || parsedText.EndsWith("j")))
{
parts = parsedText.Split('+');
if (parts.Length == 2)
return
new Complex(
real: double.Parse(parts[0].Trim()),
imaginary: double.Parse(parts[1].Substring(0, parts[1].Length - 1).Trim())
);
throw new ArgumentException("Complex number format not recognised (multiple '+' chars)");
}
else if (parsedText.Substring(1).Contains("-") && (parsedText.EndsWith("i") || parsedText.EndsWith("j")))
{
parts = parsedText.Substring(1).Split('-');
if (parts.Length == 2)
return
new Complex(
real: double.Parse(parsedText.Substring(0, 1) + parts[0].Trim()),
imaginary: -double.Parse(parts[1].Substring(0, parts[1].Length - 1).Trim())
);
throw new ArgumentException("Complex number format not recognised (multiple '+' chars)");
}
else if (parsedText.Contains(","))
{
parts = parsedText.Split(',');
if (parts.Length == 2)
return
new Complex(
real: Double.Parse(parts[0].Trim()),
imaginary: Double.Parse(parts[1].Trim())
);
int ix = parsedText.IndexOf(", ");
if (ix < 1)
throw new ArgumentException("Complex number format not recognised (ambiguous use of commas)");
return
new Complex(
real: double.Parse(parsedText.Substring(0, ix).Trim()),
imaginary: double.Parse(parsedText.Substring(ix + 1).Trim())
);
}
else
throw new ArgumentException("Complex number format not recognised");
}
else
throw new ArgumentException("Complex number not enclosed in parentheses");
}
public static bool ComplexTryParse(string text, out Complex ComplexOut)
{
try
{
ComplexOut = ComplexParse(text);
return true;
}
catch (Exception)
{
ComplexOut = new Complex(0.0, 0.0);
return false;
}
}
}
and to use as extension methods for string:
public static class StringExtensions
{
public static Complex ComplexParse(this string fromText) =>
Complex2.ComplexParse(fromText);
public static bool ComplexTryParse(this string fromText, out Complex result) =>
Complex2.ComplexTryParse(fromText, out result);
}
Sample testing:
class Program
{
static void Main(string[] args)
{
TryComplex("(1.0,0.5)");
TryComplex("(1.1+0.55i)");
TryComplex(" ( 1.023 + 0.512 j ) ");
TryComplex("(0, -1)");
TryComplex("(0-1i)");
TryComplex("(-10-2j)");
TryComplex("(-10,-3)");
TryComplex(" ( 1.8-1i ) ");
TryComplex(" ( 1.9+1i ) ");
TryComplex("(1,4, 2,5)");
TryComplex(" ( 1,1i ) ");
TryComplex("(1,4,2,5)");
TryComplex(" ( 1.023 + 0.512 + j ) ");
TryComplex(" ( 1.023, 0.512 j ) ");
TryComplex(" ( 1.023i 0.512 j ) ");
Console.ReadKey();
}
static void TryComplex(string text)
{
Console.Write($"Trying {text}: ");
try
{
Complex result = text.ComplexParse();
Console.WriteLine($"({result.Real}, {result.Imaginary})");
}
catch (Exception ex)
{
Console.WriteLine($"*** Failed: {ex.Message} ***");
}
}
}
Note: For these to work, I have used
using System.Numerics;
using static ComplexParser.Complex2;
to save having to use namespace prefixes
Hope this is of some use.
|
|
|
|
|
There's a few edge cases that would break that code - including complex numbers shown in the Microsoft docs. For example:
TryComplex("(-8.98846567431158E+307, -8.98846567431158E+307)"); That's probably why Microsoft doesn't support the X+Yi syntax by default.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
There's probably a lot of edge cases that would break the code. It uses the QAD design model (Quick And Dirty) aka "just good enough".
|
|
|
|
|
I've just tried your example (plus its x+yi and x-yi equivalents) with the code that I wrote yesterday and the results are not as bad as one might have expected:
Trying (-8.98846567431158E+307, -8.98846567431158E+307): (-8.98846567431158E+307, -8.98846567431158E+307)
Trying (-8.98846567431158E+307,-8.98846567431158E+307): (-8.98846567431158E+307, -8.98846567431158E+307)
Trying (-8.98846567431158E+307+-8.98846567431158E+307i): *** Failed: Complex number format not recognised (multiple '+' chars) ***
Trying (-8.98846567431158E+307-8.98846567431158E+307i): *** Failed: Complex number format not recognised (multiple '+' chars) *** The sample you cited works! As does dropping the space after the comma.
The x+yi and x-yi equivalents do throw an exception, but the exception message is reasonably explicit as to where the problem is. If the OP wants to check for + after an E/e followed by zero or more spaces then I'll leave it as an exercise ... it isn't rocket science to do, but could get a bit messy.
|
|
|
|
|
If you are not familiar with this technique, I will publish a Tip/Trick soon.
Assuming you know how a nested inner class (which implements an Interface) can be declared 'private, and still be accessed by public methods in the enclosing outer class: which does make direct access to inner classes of the OuterClass prohibited.
Do you think the technique shown here is evil, undesirable, or ... ?
usage:
OuterClass1 oc1 = new OuterClass1();
var cat1 = oc1.AddSomething(new Cat("cat1", "meow"));
var cat2 = oc1.AddSomething(new Cat("cat2", "hiss"));
var dog1 = oc1.AddSomething(new Dog("dog1"));
var cat1instance = oc1.GetSomething("cat1");class:
using System;
using System.Collections.Generic;
using System.Linq;
namespace NestedClassExample1
{
public interface ISomething1
{
string Name { get; }
}
public class OuterClass1
{
private List<ISomething1> Somethings = new List<ISomething1>();
internal ISomething1 AddSomething(ISomething1 newsomething)
{
Somethings.Add(newsomething);
return newsomething;
}
internal ISomething1 GetSomething(string name)
{
return Somethings.FirstOrDefault(smtng => smtng.Name == name);
}
}
public class Cat : ISomething1
{
public Cat(string name, string sound = "")
{
Name = name;
CatSound = sound;
}
public string Name { get; }
public string CatSound { set; get; }
}
public class Dog : ISomething1
{
public Dog(string name, string sound = "")
{
Name = name;
DogSound = sound;
}
public string Name { get; }
public string DogSound { set; get; }
}
public class Tiger : ISomething1
{
public Tiger(string name) { Name = name; }
public string Name { get; }
}
}
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
modified 12-May-22 6:18am.
|
|
|
|
|
Either I'm asleep, or I'm missing something - I can't see anything accessing private members outside nested classes ... 
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
|
|
|
|
|
Hi Griff, I bet my brain-fog right now is thicker than yours
Of course, you are right that inner nested classes declared 'private are inaccessible in all cases to users of instances of the Outer class.
In this case, it is the fact the inner class 'Something1 (declared 'private) inherits from a public interface that allows the 'AddSomething method in the outer class to both update the private list, and return the new 'ISomething1.
Any other access declaration on the 'Something1 class would mean it is exposed to users of the outer class.
imho, this is part of the weirdness with which nested classes are handled in C#.
And, in my head, now, I see using this method is a way ... awkward ! ... to achieve strong encapsulation, as taught by Saint SOLID.
I eagerly await enlightenment !
cheers, Bill
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
|
|
|
|
|
Being pedantic, the class implements the interface; it doen't inherit from it.
And there's no actual reference to the nested Something1 class anywhere in that code. You could remove that class, and the code would continue to run and function as expected.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
"pedantic" ? oh, we know what to do with that 
Richard Deeming wrote: And there's no actual reference to the nested Something1 class anywhere in that code.
That's the point: the consumer of an instance of 'OuterClass has no direct access to the plumbing ... except through those publicly exposed methods.
Richard Deeming wrote: You could remove that class, and the code would continue to run and function as expected.
Wrong.
See Harold's response and my reply below.
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
modified 11-May-22 23:40pm.
|
|
|
|
|
|
Richard Deeming wrote: The AddSomething and GetSomething methods depend on the interface, not the unused nested class.
Hi, Thanks for looking further into the code !
You are correct that the class definition for 'ISomething1 is not used in the use-case example (it's a fossil from an earlier version), and I will delete that from the code posted here, thanks ! Sorry for any confusion that added.
Those two methods, by design, can only be accessed via an instance of 'OuterClass; while they use the public Interface, I don't see them as "dependent" in the usual sense of that term.
My hypothesis here is limited in scope: does this technique contribute to the encapsulation of the collections of Instances in the outer class that implement the Interface.
This code example is, by design, a terse example.
I also use generics in a way not shown in this example ... imho, does not need to be shown.
The "big picture," imho, is:
1) if you are managing collections of mixed Types (which requires use of Interface), where extensibility ... the user can create new Types that use the Interface ... is important ...
2) and, you want maximum encapsulation of those collections
3) what are good techniques ?
cheers, Bill
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
modified 12-May-22 6:17am.
|
|
|
|
|
I'm not sure I follow. Are you saying you want to prevent the user from creating new types that implement the interface outside of your assembly?
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
Richard Deeming wrote: prevent the user from creating new types that implement the interface outside of your assembly?
That is a very logical next step, but this example is limited to only preventing use of the OuterClass' collections,
In this example, the end user is free to create as many Dogs and Cats as they can afford
p.s. the code gets more interesting when you define an encapsulated instantiator like this:
internal T NewInstance<T>(params object[] args)
where T : class, ISomething1
{
var ttype = typeof(T);
ISomething1 instance = null;
instance = (T) Activator.CreateInstance(ttype, args);
Somethings.Add(instance);
return (T) instance;
}Which is, of course, only one way to handle instantiation; I tend to avoid 'Activator.CreateInstance for reasons I am sure you are aware of.
Returning to the "big picture:" what strategies do you use to increase the encapsulation of classes that maintain collections of mixed types ?
cheers, Bill
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
|
|
|
|
|
I'm still not entire sure what you're trying to achieve.
If a generic collection contains mixed types, those types must either inherit from a base class, or implement an interface. If the collection class is public, then trying to further restrict the types it can contain to those in the current assembly, or an approved list of assemblies, is usually a sign of a broken design.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
Thanks !Richard Deeming wrote: If the collection class is public, then trying to further restrict the type ...
In this case, the 'OuterClass is public; the whole point of this (encapsulation) is allowing access to the internal collections inside that outer class only by methods I expose.
I think you are reading into this some broader issue.Richard Deeming wrote: ... to those in the current assembly, or an approved list of assemblies, is usually a sign of a broken design.
I can easily imagine a scenario where a design of an outer class with private internal classes would be very useful. But, that is not relevant here.
cheers, Bill
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
|
|
|
|
|
I'd be more impressed if that code actually compiled. But even then I don't really understand what point you are trying to demonstrate.
|
|
|
|
|
Thanks, added the missing 'GetSomething method, and verified it compiles/runs as expected..
Re "point:" please see response to Griff; if there is anyone on the planet I think would instantly see the "point," and be aware of the issue ... and blow my mind with a better technique ...I would pick: you
«The mind is not a vessel to be filled but a fire to be kindled» Plutarch
|
|
|
|
|
If the trick is intended to center around being able to return instances of a private class (which otherwise results in the dreaded "inconsistent accessibility" error) in an at least someone useful way (you can always return it as object, but then what?), then that's known .. by me at least, but I guess in general. The code doesn't really show that in action though. I wouldn't rate that an evil trick, more like "limited usefulness".
Otherwise if it's supposed to be a different trick then I didn't get it.
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
