---
layout: default
title: "CONTRIBUTING"
parent: "Guides"
nav_order: 6
---
# Contributing to BrightSword
Thank you for your interest in contributing to BrightSword! This document provides guidelines and information for contributors.
## Code of Conduct
We are committed to providing a welcoming and inspiring community for all. Please be respectful and constructive in your interactions.
## How Can I Contribute?
### Reporting Bugs
Before creating bug reports, please check existing issues to avoid duplicates.
**Good bug reports include:**
- Clear, descriptive title
- Steps to reproduce the issue
- Expected vs actual behavior
- Environment details (.NET version, OS, etc.)
- Code samples or error messages
- Screenshots if applicable
### Suggesting Enhancements
Enhancement suggestions are welcome! Please provide:
- Clear use case and motivation
- Detailed description of the proposed functionality
- Examples of how it would be used
- Potential alternatives considered
### Pull Requests
1. **Fork the repository** and create your branch from `main`:
```bash
git checkout -b feature/amazing-feature
```
2. **Make your changes**:
- Follow the coding standards (see below)
- Add tests for new functionality
- Update documentation as needed
3. **Test your changes**:
```bash
./build.ps1 -Target Test
```
4. **Build and verify**:
```bash
./build.ps1 -Target CI
```
5. **Commit your changes**:
- Use clear commit messages
- Follow conventional commit format (see below)
6. **Push** to your fork and **create a Pull Request**
## Development Setup
### Prerequisites
- .NET 10 SDK or later
- Git
- A code editor (Visual Studio, VS Code, Rider)
### Clone and Build
```bash
# Clone your fork
git clone https://github.com/YOUR_USERNAME/BrightSword.git
cd BrightSword
# Add upstream remote
git remote add upstream https://github.com/johnazariah/brightsword.git
# Build
./build.ps1
```
## Coding Standards
### C# Style Guidelines
- Follow [Microsoft C# Coding Conventions](https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions)
- Use meaningful names for variables, methods, and classes
- Keep methods small and focused
- Avoid deep nesting (max 3-4 levels)
- Use nullable reference types (`#nullable enable`)
### Naming Conventions
- **Classes**: PascalCase (e.g., `ActionBuilder`)
- **Methods**: PascalCase (e.g., `BuildAction`)
- **Properties**: PascalCase (e.g., `InstanceParameter`)
- **Parameters**: camelCase (e.g., `propertyInfo`)
- **Private fields**: _camelCase (e.g., `_cachedDelegate`)
- **Constants**: PascalCase (e.g., `DefaultTimeout`)
### Code Organization
```csharp
// Namespaces - alphabetically
using System;
using System.Collections.Generic;
using System.Linq;
namespace BrightSword.PackageName
{
///
/// XML documentation for class
///
public class MyClass
{
// Private fields
private readonly IService _service;
// Constructors
public MyClass(IService service)
{
_service = service;
}
// Public properties
public string Name { get; set; }
// Public methods
public void DoSomething()
{
// Implementation
}
// Private methods
private void HelperMethod()
{
// Implementation
}
}
}
```
### XML Documentation
All public APIs must have XML documentation:
```csharp
///
/// Brief description of what the method does.
///
/// Description of the input parameter.
/// Description of what is returned.
///
/// Thrown when is null.
///
///
///
/// var result = MyMethod("example");
/// Console.WriteLine(result);
///
///
///
/// Additional notes about usage or behavior.
///
public string MyMethod(string input)
{
ArgumentNullException.ThrowIfNull(input);
return input.ToUpper();
}
```
## Testing Guidelines
### Writing Tests
- Use descriptive test method names: `MethodName_Scenario_ExpectedBehavior`
- Follow Arrange-Act-Assert pattern
- Test both happy paths and edge cases
- Use meaningful test data
- Keep tests focused and independent
### Test Organization
```csharp
[TestClass]
public class MyClassTests
{
[TestMethod]
public void DoSomething_WithValidInput_ReturnsExpectedResult()
{
// Arrange
var myClass = new MyClass();
var input = "test";
// Act
var result = myClass.DoSomething(input);
// Assert
Assert.AreEqual("expected", result);
}
[TestMethod]
public void DoSomething_WithNullInput_ThrowsArgumentNullException()
{
// Arrange
var myClass = new MyClass();
// Act & Assert
var exception = new Action(() => myClass.DoSomething(null))
.ExpectException();
Assert.IsNotNull(exception);
}
}
```
## Commit Message Format
We follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
```
():