What does С# SemaphoreSlim guarantee? Is it full memory barrier? What we can be sure of code between two different semaphore Wait() and Release()?
Does sequence of different SemaphoreSlim Wait(), Release() and Interlocked methods and Volatile. Write/Read always keep it order in every threads?
public T Dequeue()
{
canReadCountSemaphoreSlim.Wait();
int i = Interlocked.Decrement(ref end);
T val = Volatile.Read(ref buf[i]);
canWriteCountSemaphoreSlim.Release();
return val;
}
public void Enqueue(T val)
{
canWriteCountSemaphoreSlim.Wait();
int i = Interlocked.Decrement(ref start);
Volatile.Write(ref buf[i], val);
canReadCountSemaphoreSlim.Release();
}
Full code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
namespace Program
{
public class BlockingRingQueue<T> where T: class
{
const int BUFSIZE_LOG2 = 10;
const int BUFSIZE = 1 << BUFSIZE_LOG2;
T[] buf = new T[BUFSIZE];
int start = 0;
int end = 0;
SemaphoreSlim canReadCountSemaphoreSlim = new SemaphoreSlim(0);
SemaphoreSlim canWriteCountSemaphoreSlim = new SemaphoreSlim(BUFSIZE);
public T Dequeue()
{
canReadCountSemaphoreSlim.Wait();
int i = Interlocked.Decrement(ref end);
i = PositiveMod(i, BUFSIZE);
T val = Volatile.Read(ref buf[i]);
canWriteCountSemaphoreSlim.Release();
return val;
}
public void Enqueue(T val)
{
canWriteCountSemaphoreSlim.Wait();
int i = Interlocked.Decrement(ref start);
i = PositiveMod(i, BUFSIZE);
Volatile.Write(ref buf[i], val);
canReadCountSemaphoreSlim.Release();
}
static int PositiveMod(int a, int b) => ((a % b) + b) % b;
}
public class Program
{
const int READ_THREAD_COUNT = 3;
static BlockingRingQueue<string> queue = new BlockingRingQueue<string>();
public static void Main(string[] args)
{
new Thread(() => Pushing("ABCD")) { Name = "0" }.Start();
for(int i = 1; i <= READ_THREAD_COUNT; i++)
new Thread(Poping) { Name = i.ToString() }.Start();
}
public static void Poping()
{
while(true)
{
RandSpinWait();
var val = queue.Dequeue();
if("" == val)
break;
Console.WriteLine(val + Thread.CurrentThread.Name + ' ');
}
//Console.WriteLine('!' + Thread.CurrentThread.Name + ' ');
}
public static void Pushing(string chars)
{
RandSpinWait();
var vals = chars.ToCharArray().Select(c => $"{c}")
.Concat(Enumerable.Repeat("",READ_THREAD_COUNT));
foreach(string v in vals)
queue.Enqueue(v);
}
public static void RandSpinWait() => Thread.SpinWait(new Random().Next(1));
}
}
I'm struggling to parse user input to a global integer
When I give the global scoreString a value after declaring it like this --- static string scoreString = "55"; --- it works
static string scoreString = "55";
static bool scoreBool = int.TryParse(scoreString, out score);
static int score;
static void Main(string[] args)
{
Console.WriteLine("====STUDENT AVERAGE CHECKER====");
AverageMaker();
if (scoreBool)
{
Console.WriteLine("Parsing good");
Console.WriteLine(score);
}
else
{
Console.WriteLine("Parsing fail");
Console.WriteLine(score);
}
Console.Read();
}
public static void AverageMaker()
{
Console.WriteLine("-----Enter score---");
scoreString = Console.ReadLine();
}
You are of parsing scoreString out side of Main() function. Parse it inside AverageMaker() function, after reading string from Console
something like,
public static void AverageMaker()
{
Console.WriteLine("-----Enter score---");
scoreString = Console.ReadLine();
scoreBool = int.TryParse(scoreString, out score); //This was missing
}
Remove new line character as result of readline : scoreString = scoreString.Replace("\r\n", string.Empty); and try to parse
I am having some trouble with visual studio, as it says it won't compile. I can't figure out what the problem is. it says something like it can't convert from void to bool, even though there is no 'bool'. Here is my code:
using System;
namespace ConsoleApplication14
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(myFunction(14));
}
public static void myFunction(int x)
{
return x + 2;
}
}
What is causing that compile error?
try this
class Program
{
static void Main(string[] args)
{
Console.WriteLine(myFunction(14));
}
public static int myFunction(int x)
{
return x + 2;
}
}
You are returning an Int. Void has no return type. To make this work you will need
public static int myFunction(int x)
{
return x + 2;
}
The type void indicates that a mamber does not return anything. So when your method is marked as such it should not return a value. However when you call Console.WriteLine you need a value to be printed to the console.
Furthermore your method should make a calculation and return something - in your case an int. So instead of defining your method as void let it return an int:
class Program
{
static void Main(string[] args)
{
Console.WriteLine(myFunction(14));
}
public static int myFunction(int x)
{
return x + 2;
}
}
In your myfunction method your returning some int value but myfunction return type is void in your code. Plaese change void to int and the application will work.
namespace ConsoleApplication1
{
class Program
{
public static int myFunction(int x)
{
return x + 2;
}
static void Main(string[] args)
{
Console.WriteLine(myFunction(14));
Console.ReadLine();
}
}
}
From my main code I'm calling a method of a class meth2 which calls another method from another class meth1. It is important for me to respect this structure.
These methods make an assignment of values that are previously defined in the classes but I am not able to get a proper result in my command window (just a 0 instead of a 132). I assume I'm missing something.
Does anybody has an idea? Here's the code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace workingWithClasses
{
class meth1
{
public int op1;
public int multiply(int mult)
{
return op1 = 44 * mult;
}
}
class meth2
{
public int CallFuncsClass(int multiplicator)
{
return m1.multiply(int multiplicator);
}
}
class Program
{
static void Main(string[] args)
{
meth1 m1 = new meth1();
meth2 m2 = new meth2();
m2.CallFuncsClass(3);
int result_m1 = m1.op1;
Console.WriteLine(opm1);
Console.ReadKey();
}
}
}
Thanks a lot!
namespace workingWithClasses
{
public class meth1
{
public int op1;
public int multiply(int mult)
{
return op1 = 44 * mult;
}
}
public class meth2
{
meth1 m1 = new meth1();
public int CallFuncsClass(int multiplicator)
{
return m1.multiply( multiplicator);
}
}
class Program
{
static void Main(string[] args)
{
meth2 m2 = new meth2();
int result_m2 = m2.CallFuncsClass(3);
Console.WriteLine(result_m2);
Console.ReadKey();
}
}
}
This code won't compile, right? This line return m1.multiply(int multiplicator); is out of the place. You need to define what is m1. I guess you are looking for dependency injection. You can do this via constructor, so
class meth2
{
private meth1 _m1;
meth2(meth1 m1)
{
if(m1 == null) throw new ... // check input params
_m1 = m1;
}
public int CallFuncsClass(int multiplicator)
{
return _m1.multiply(int multiplicator);
}
}
The usage will be
meth1 m1 = new meth1();
meth2 m2 = new meth2(m1);
m2.CallFuncsClass(3);
Bonus points
Name your classes correctly, instead of meth1 it should be something like Calculator
Don't use public fields: public int op1;. It should be private
Usually you would want your classes to be public, by default the class is internal. In this way you can use it outside a single library
Check parameters for correct value, throw exception if something is incorrect
Make multiply static on class meth1:
public static int multiply(int mult)
Also don't use 'op1', just return the result of the operation.
Call like this:
return meth1.multiply(int multiplicator);
Here is the solution
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace workingWithClasses
{
class meth1
{
public int op1;
public int multiply(int mult)
{
return op1 = 44 * mult;
}
}
class meth2
{
public int CallFuncsClass(int multiplicator)
{
meth1 m1=new meth1();
return m1.multiply(multiplicator);
}
}
class Program
{
static void Main(string[] args)
{
meth2 m2 = new meth2();
int result_m1=m2.CallFuncsClass(3);
Console.WriteLine(result_m1);
Console.ReadKey();
}
}
}
If you want to call methods from meth1 from within meth2 like that (without creating an object of type meth1) you need to make multiply() static.
This will allow it to be used in the manner you're using:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace workingWithClasses
{
class meth1
{
//note statics
static int op1;
static int multiply(int mult)
{
return op1 = 44 * mult;
}
}
class meth2
{
public int CallFuncsClass(int multiplicator)
{
//access to multiply() is valid here
return meth1.multiply(multiplicator);
}
}
class Program
{
static void Main(string[] args)
{
meth1 m1 = new meth1();
meth2 m2 = new meth2();
m2.CallFuncsClass(3);
int result_m1 = m1.op1;
Console.WriteLine(opm1);
Console.ReadKey();
}
}
}
Quick question.
I am writing a program to find all the permutations of a set of characters I input into the application.
This part works perfectly.
My problem is that I need to check all the permutations of the characters against a text file I use as a dictionary.
Ex. If I input the characters TSTE the outputs givin are tset,ttse,ttes,tets,test,stte,stet,sett...
I only want to print the valid words like tset,sett,stet,test,tets. where ttse,ttes,stte is not printed.
The code I have so far is as follows.
I have been scracthing at the edges of my scull for the past few days and just cant seem to find a way to do it.
Please if there is anything you can see that I have missed?
Thank you
static void Main(string[] args)
{
Console.BufferHeight = Int16.MaxValue - 1;
Console.WindowHeight = 40;
Console.WindowWidth = 120;
Permute p = new Permute();
var d = Read();
string line;
string str = System.IO.File.ReadAllText("Dictionary.txt");
while ((line = Console.ReadLine()) != null)
{
char[] c2 = line.ToArray();
p.setper(c2);
}
}
static Dictionary<string, string> Read()
{
var d = new Dictionary<string, string>();
using (StreamReader sr = new StreamReader("Dictionary.txt"))
{
string line;
while ((line = sr.ReadLine()) != null)
{
string a = Alphabet(line);
string v;
if (d.TryGetValue(a, out v))
{
d[a] = v + "," + line;
}
else
{
d.Add(a, line);
}
}
}
return d;
}
static string Alphabet(string s)
{
char[] a = s.ToCharArray();
Array.Sort(a);
return new string(a);
}
static void Show(Dictionary<string, string> d, string w)
{
string v;
if (d.TryGetValue(Alphabet(w), out v))
{
Console.WriteLine(v);
}
else
{
Console.WriteLine("-----------");
}
}
}
class Permute
{
private void swap(ref char a, ref char b)
{
if (a == b) return;
a ^= b;
b ^= a;
a ^= b;
}
public void setper(char[] list)
{
int x = list.Length - 1;
go(list, 0, x);
}
public void go(char[] list1, int k, int m)
{
if (k == m)
{
Console.WriteLine(list1);
Console.WriteLine(" ");
}
else
{
for (int i = k; i <= m; i++)
{
swap(ref list1[k], ref list1[i]);
go(list1, k + 1, m);
swap(ref list1[k], ref list1[i]);
}
}
}
you just missed Show(d, line); i loop.
change like this.
while ((line = Console.ReadLine()) != null)
{
char[] c2 = line.ToArray();
p.setper(c2);
Console.WriteLine(" combinations which are in Dictionary are:");
Show(d, line);
}
then ..
you didn't required dictionary
use List<string> Dic=new List<string>();// declare it in globally
Dic.add(line); //each line in dictionary
before printing each word
if(Dic.contains(word))
print it;
else{ //no printing }
Not possible with current state.
It's possible because
If the "dictionary.txt" was your input, then you did not define what are the valid words.
You at leaset need another dictionary to define those valid words or an algorithm to decide what those are and what those are not.
If the input is from UI and "dictionary.txt" is the defined valid words, you don't need to the permute the input, just search the input from "dictionary.txt".
However, your Read method is improvable, like
static Dictionary<String, String> Read(String path) {
return (
from line in File.ReadAllLines(path)
where false==String.IsNullOrEmpty(line)
group line by Alphabet(line) into g
select
new {
Value=String.Join(",", g.ToArray()),
Key=g.Key
}
).ToDictionary(x => x.Key, x => x.Value);
}
Although for the valid words are as I mentioned in another answer, not possible with your current state, I've make the code pretty clear for you.
It finally the code, is separated in three parts. They are Permutable<T>, ConsoleHelper and the ConsoleApplication1.Program with an utility Permutation class.
Permutable<T> (Permutable.cs)
using System.Collections.Generic;
using System.Collections;
using System;
public partial class Permutable<T>: IEnumerable {
public static explicit operator Permutable<T>(T[] array) {
return new Permutable<T>(array);
}
static IEnumerable Permute<TElement>(IList<TElement> list, int depth, int count) {
if(count==depth)
yield return list;
else {
for(var i=depth; i<=count; ++i) {
Swap(list, depth, i);
foreach(var sequence in Permutable<T>.Permute(list, 1+depth, count))
yield return sequence;
Swap(list, depth, i);
}
}
}
static void Swap<TElement>(IList<TElement> list, int depth, int index) {
var local=list[depth];
list[depth]=list[index];
list[index]=local;
}
IEnumerator IEnumerable.GetEnumerator() {
return this.GetEnumerator();
}
public IEnumerator<IList<T>> GetEnumerator() {
var list=this.m_List;
if(list.Count>0)
foreach(IList<T> sequence in Permutable<T>.Permute(list, 0, list.Count-1))
yield return sequence;
}
protected Permutable(IList<T> list) {
this.m_List=list;
}
IList<T> m_List;
}
ConsoleHelper (ConsoleHelper.cs)
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Drawing;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public static partial class ConsoleHelper {
[StructLayout(LayoutKind.Sequential)]
public struct RECT {
public static explicit operator Rectangle(RECT rect) {
return new Rectangle {
X=rect.Left,
Y=rect.Top,
Width=rect.Right-rect.Left,
Height=rect.Bottom-rect.Top
};
}
public int Left;
public int Top;
public int Right;
public int Bottom;
}
[DllImport("user32.dll", SetLastError=true)]
static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int Width, int Height, bool repaint);
[DllImport("user32.dll", SetLastError=true)]
static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
[DllImport("kernel32.dll", SetLastError=true)]
static extern IntPtr GetConsoleWindow();
public static void CenterScreen() {
RECT rect;
var hWnn=ConsoleHelper.GetConsoleWindow();
var workingArea=Screen.GetWorkingArea(Point.Empty);
ConsoleHelper.GetWindowRect(hWnn, out rect);
var rectangle=(Rectangle)rect;
rectangle=
new Rectangle {
X=(workingArea.Width-rectangle.Width)/2,
Y=(workingArea.Height-rectangle.Height)/2,
Width=rectangle.Width,
Height=rectangle.Height
};
ConsoleHelper.MoveWindow(
hWnn,
rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height,
true
);
}
}
ConsoleApplication1.Program & Permutation (Program.cs)
using System.Collections;
using System.IO;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public partial class Permutation {
public static Permutation FromFile(String path) {
return new Permutation(path);
}
public static String GetSortedAlphabet(String text) {
var array=text.ToArray();
Array.Sort(array);
return new String(array);
}
public Dictionary<String, String> Dictionary {
private set;
get;
}
public FileInfo SourceFile {
private set;
get;
}
public Permutation(String path) {
this.Dictionary=(
from line in File.ReadAllLines(path)
where false==String.IsNullOrEmpty(line)
group line by Permutation.GetSortedAlphabet(line) into g
select
new {
Value=String.Join(", ", g.Distinct().ToArray()),
Key=g.Key
}
).ToDictionary(x => x.Key, x => x.Value);
this.SourceFile=new FileInfo(path);
}
}
namespace ConsoleApplication1 {
partial class Program {
static void ProcessLine(IList<char> input) {
Console.WriteLine();
if(input.Count>0) {
var inputArray=input.ToArray();
var key=Permutation.GetSortedAlphabet(new String(inputArray));
var dict=Program.Permutation.Dictionary;
var hasKey=dict.ContainsKey(key);
var source=Permutation.SourceFile;
Console.WriteLine("Possible permutations are: ");
foreach(var sequence in (Permutable<char>)inputArray)
Console.WriteLine("{0}", new String(sequence.ToArray()));
Console.WriteLine("Acceptable in file '{0}' are: ", source.FullName);
Console.WriteLine("{0}", hasKey?dict[key]:"<none>");
Console.WriteLine();
input.Clear();
}
Console.Write(Prompt);
}
static void ProcessChar(IList<char> input, char keyChar) {
Console.Write(keyChar);
input.Add(keyChar);
}
static void ProcessExit(IList<char> input, char keyChar) {
Console.WriteLine();
Console.Write("Are you sure to exit? (Press Esc again to exit)");
input.Add(keyChar);
}
static bool ProcessLast(IList<char> input, char keyChar) {
var last=input.Count-1;
if(0>last||input[last]!=(char)ConsoleKey.Escape)
return false;
input.Clear();
return true;
}
public static Permutation Permutation {
private set;
get;
}
public static String Prompt {
private set;
get;
}
}
partial class Program {
static void Main(String[] args) {
Console.BufferHeight=short.MaxValue-1;
Console.SetWindowSize(120, 40);
ConsoleHelper.CenterScreen();
var input=new List<char>(char.MaxValue);
Program.Permutation=Permutation.FromFile(#"c:\dictionary.txt");
Program.Prompt="User>\x20";
Program.ProcessLine(input);
for(; ; ) {
var keyInfo=Console.ReadKey(true);
var keyChar=keyInfo.KeyChar;
var keyCode=keyInfo.Key;
if(ConsoleKey.Escape==keyCode) {
if(Program.ProcessLast(input, keyChar))
break;
Program.ProcessExit(input, keyChar);
continue;
}
if(ConsoleKey.Enter==keyCode) {
Program.ProcessLine(input);
continue;
}
if(default(ConsoleModifiers)!=keyInfo.Modifiers)
continue;
if(0x1f>keyChar||keyChar>0x7f)
continue;
if(Program.ProcessLast(input, keyChar))
Console.WriteLine();
Program.ProcessChar(input, keyChar);
}
}
}
}
The ConsoleHelper class is only use for ceteral your resized console window, that you can test the program more comfortable. The Permutable class is what I fully re-designed from your original class; it now come with IEnumerable to permute, and also a generic class.
The Permutation class, is like a utility class, itself provide a FromFile method as your original Read, and stores the Dictionary<String, String> as a property. The original method Alphabet is renamed GetSortedAlphabet for more semantical.
The Program class has four main static ProcessXXX methods, they are
ProcessChar: processes for a char of the range from 0x20 to 0x7f
ProcessLine: processes for Enter pressed
ProcessExit: processes for Excape pressed
ProcessLast: additional processing for ProcessLine and ProcessExit
Yes, I meant to make them have the same length of name. For more, Program class have two static properties; Permutation for storing a instance of class Permutation, and Prompt is a string for prompting user.
When your input is not defined in "c:\dictionary.txt", the prompt of "Acceptable in file .." will get you "<none>".
The exit command is twice-Escape key press, you would see
Are you sure to exit? (Press Esc again to exit)
and if you press Enter or other keys, it back to the initial state.
That's all. Now it's time to discover the finally problem you've encountered. After you test with this program, you might describe you questions and issues more clearly.
Good luck!
Thank you for all your feedback.
I have finally figured it out and found a solution to the problem I was having.
static void Main(string[] args)
{
Console.BufferHeight = Int16.MaxValue - 1;
Console.WindowHeight = 40;
Console.WindowWidth = 120;
Console.WriteLine("Enter your caracters for the anagram: ");
//var d = Read();
string line;
//string DictionaryInput = System.IO.File.ReadAllText("Dictionary.txt");
while ((line = Console.ReadLine()) != null)
{
Console.WriteLine("Your results are: ");
char[] charArray = line.ToArray();
//Show(d, line); //Using this to check that words found are the correct words in the dictionary.
setper(charArray);
Console.WriteLine("-----------------------------------------DONE-----------------------------------------");
Console.WriteLine("Enter your caracters for the anagram: ");
File.Delete("Permutations.txt");
}
}
static void swap(ref char a, ref char b)
{
if (a == b) return;
a ^= b;
b ^= a;
a ^= b;
}
static void setper(char[] list)
{
int x = list.Length - 1;
permuteWords(list, 0, x);
}
static void permuteWords(char[] list1, int k, int m)
{
if (k == m)
{
StreamWriter sw = new StreamWriter("Permutations.txt", true);
sw.WriteLine(list1);
sw.Close();
Regex permutationPattern = new Regex(new string(list1));
string[] permutations = File.ReadAllLines("Permutations.txt");
Regex pattern = new Regex(new string(list1));
string[] lines = File.ReadAllLines("Dictionary.txt");
foreach (string line in lines)
{
var matches = pattern.Matches(line);
if (pattern.ToString() == line)
{
Console.WriteLine(line);
}
}
}
else
{
for (int i = k; i <= m; i++)
{
swap(ref list1[k], ref list1[i]);
permuteWords(list1, k + 1, m);
swap(ref list1[k], ref list1[i]);
}
}
}